diff options
Diffstat (limited to 'clang/test')
125 files changed, 69953 insertions, 397 deletions
diff --git a/clang/test/AST/HLSL/resource_binding_attr.hlsl b/clang/test/AST/HLSL/resource_binding_attr.hlsl index c6d93b9..2de0674 100644 --- a/clang/test/AST/HLSL/resource_binding_attr.hlsl +++ b/clang/test/AST/HLSL/resource_binding_attr.hlsl @@ -92,9 +92,8 @@ cbuffer CB3 { StructuredBuffer<float> SB[10]; // CHECK: VarDecl {{.*}} SB2 'StructuredBuffer<float>[10]' +// CHECK: HLSLVkBindingAttr {{.*}} 2 0 // DXIL: HLSLResourceBindingAttr {{.*}} Implicit -// DXIL-NOT: HLSLVkBindingAttr -// SPV: HLSLVkBindingAttr {{.*}} 2 0 // SPV-NOT: HLSLResourceBindingAttr {{.*}} Implicit [[vk::binding(2)]] StructuredBuffer<float> SB2[10]; diff --git a/clang/test/AST/HLSL/vk_binding_attr.hlsl b/clang/test/AST/HLSL/vk_binding_attr.hlsl index d08165d..13e7544 100644 --- a/clang/test/AST/HLSL/vk_binding_attr.hlsl +++ b/clang/test/AST/HLSL/vk_binding_attr.hlsl @@ -10,8 +10,7 @@ // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 102 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 -// SPV: HLSLVkBindingAttr {{.*}} 23 102 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 23 102 [[vk::binding(23, 102)]] StructuredBuffer<float> Buf; // CHECK: VarDecl {{.*}} Buf2 'StructuredBuffer<float>':'hlsl::StructuredBuffer<float>' @@ -23,8 +22,7 @@ // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 1 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 23 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 102 -// SPV: HLSLVkBindingAttr {{.*}} 14 1 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 14 1 // CHECK: HLSLResourceBindingAttr {{.*}} "t23" "space102" [[vk::binding(14, 1)]] StructuredBuffer<float> Buf2 : register(t23, space102); @@ -37,15 +35,13 @@ // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 23 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 102 -// SPV: HLSLVkBindingAttr {{.*}} 14 0 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 14 0 // CHECK: HLSLResourceBindingAttr {{.*}} "t23" "space102" [[vk::binding(14)]] StructuredBuffer<float> Buf3 : register(t23, space102); // CHECK: HLSLBufferDecl {{.*}} cbuffer CB // CHECK-NEXT: HLSLResourceClassAttr {{.*}} Implicit CBuffer -// SPV-NEXT: HLSLVkBindingAttr {{.*}} 1 2 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 1 2 [[vk::binding(1, 2)]] cbuffer CB { float a; } @@ -54,15 +50,14 @@ // CHECK-NEXT: CallExpr {{.*}} 'Buffer<int>':'hlsl::Buffer<int>' // CHECK-NEXT: ImplicitCastExpr {{.*}} 'hlsl::Buffer<int> (*)(unsigned int, unsigned int, int, unsigned int, const char *)' <FunctionToPointerDecay> // SPV-NEXT: DeclRefExpr {{.*}} 'hlsl::Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' -// SPV-NEXT-SAME: CXXMethod {{.*}} '__createFromBinding' 'Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' +// SPV-NEXT-SAME: CXXMethod {{.*}} '__createFromBinding' 'hlsl::Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 24 // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 103 -// DXIL-NEXT: DeclRefExpr {{.*}} 'hlsl::Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' -// DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromImplicitBinding' 'Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' +// DXIL-NEXT: DeclRefExpr {{.*}} 'hlsl::Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' +// DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromImplicitBinding' 'hlsl::Buffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 2 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 -// SPV: HLSLVkBindingAttr {{.*}} 24 103 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 24 103 [[vk::binding(24, 103)]] Buffer<int> Buf4; // CHECK: VarDecl {{.*}} Buf5 'RWBuffer<int2>':'hlsl::RWBuffer<vector<int, 2>>' @@ -76,8 +71,7 @@ // DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromImplicitBinding' 'Buffer<int2> (unsigned int, unsigned int, int, unsigned int, const char *)' // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 3 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 -// SPV: HLSLVkBindingAttr {{.*}} 25 104 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 25 104 [[vk::binding(25, 104)]] RWBuffer<int2> Buf5; // CHECK: VarDecl {{.*}} Buf6 'RWStructuredBuffer<int>':'hlsl::RWStructuredBuffer<int>' @@ -91,6 +85,5 @@ // DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromBinding' 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 4 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 -// SPV: HLSLVkBindingAttr {{.*}} 26 105 -// DXIL-NOT: HLSLVkBindingAttr +// CHECK: HLSLVkBindingAttr {{.*}} 26 105 [[vk::binding(26, 105)]] RWStructuredBuffer<int> Buf6; diff --git a/clang/test/AST/ast-print-record-decl.c b/clang/test/AST/ast-print-record-decl.c index fd81588..394f837 100644 --- a/clang/test/AST/ast-print-record-decl.c +++ b/clang/test/AST/ast-print-record-decl.c @@ -315,4 +315,11 @@ template <int, int = 0> KW SmearedNTTPDefArgs; // PRINT-CXX-NEXT: template <int = 0, int> [[KW]] SmearedNTTPDefArgs; template <int = 0, int> KW SmearedNTTPDefArgs; +// PRINT-CXX-LABEL: Tpl +template <int> KW Tpl; +// PRINT-CXX-NEXT: template <template <int> class, template <int> class = Tpl> [[KW]] SmearedTplDefArgs; +template <template <int> class, template <int> class = Tpl> KW SmearedTplDefArgs; +// PRINT-CXX-NEXT: template <template <int> class = Tpl, template <int> class> [[KW]] SmearedTplDefArgs; +template <template <int> class = Tpl, template <int> class> KW SmearedTplDefArgs; + #endif diff --git a/clang/test/Analysis/Checkers/WebKit/objc-mock-types.h b/clang/test/Analysis/Checkers/WebKit/objc-mock-types.h index dacb713..a5fc3d7 100644 --- a/clang/test/Analysis/Checkers/WebKit/objc-mock-types.h +++ b/clang/test/Analysis/Checkers/WebKit/objc-mock-types.h @@ -178,6 +178,22 @@ __attribute__((objc_root_class)) + (NSNumber *)numberWithBool:(BOOL)value; @end +@interface NSResponder : NSObject +@end + +@interface NSApplication : NSResponder + +extern NSApplication * NSApp; + +@property (class, readonly, strong) NSApplication *sharedApplication; + +- (void)finishLaunching; +- (void)run; +- (void)stop:(id)sender; +- (void)terminate:(id)sender; + +@end + @interface SomeObj : NSObject - (instancetype)_init; - (SomeObj *)mutableCopy; diff --git a/clang/test/Analysis/Checkers/WebKit/unretained-call-args.mm b/clang/test/Analysis/Checkers/WebKit/unretained-call-args.mm index c9d2fe8..a517dbc 100644 --- a/clang/test/Analysis/Checkers/WebKit/unretained-call-args.mm +++ b/clang/test/Analysis/Checkers/WebKit/unretained-call-args.mm @@ -398,12 +398,18 @@ namespace call_with_cf_constant { void baz(const NSDictionary *); void boo(NSNumber *); void boo(CFTypeRef); - void foo() { + + struct Details { + int value; + }; + + void foo(Details* details) { CFArrayCreateMutable(kCFAllocatorDefault, 10); bar(@[@"hello"]); baz(@{@"hello": @3}); boo(@YES); boo(@NO); + boo(@(details->value)); } } @@ -582,6 +588,7 @@ struct Derived : Base { [self doWork:@"hello", RetainPtr<SomeObj> { provide() }.get(), RetainPtr<CFMutableArrayRef> { provide_cf() }.get(), OSObjectPtr { provide_dispatch() }.get()]; [self doWork:__null]; [self doWork:nil]; + [NSApp run]; } - (SomeObj *)getSomeObj { diff --git a/clang/test/Analysis/Inputs/system-header-simulator-for-protobuf.h b/clang/test/Analysis/Inputs/system-header-simulator-for-protobuf.h new file mode 100644 index 0000000..cb12b55 --- /dev/null +++ b/clang/test/Analysis/Inputs/system-header-simulator-for-protobuf.h @@ -0,0 +1,18 @@ +// Like the compiler, the static analyzer treats some functions differently if +// they come from a system header -- for example, it is assumed that system +// functions do not arbitrarily free() their parameters, and that some bugs +// found in system headers cannot be fixed by the user and should be +// suppressed. +#pragma clang system_header + +class Arena; +class MessageLite { + int SomeArbitraryField; +}; + +// Originally declared in generated_message_util.h +MessageLite *GetOwnedMessageInternal(Arena *, MessageLite *, Arena *); + +// Not a real protobuf function -- just introduced to validate that this file +// is handled as a system header. +void SomeOtherFunction(MessageLite *); diff --git a/clang/test/Analysis/LifetimeSafety/benchmark.py b/clang/test/Analysis/LifetimeSafety/benchmark.py index d2e5f0b..cd5b3081 100644 --- a/clang/test/Analysis/LifetimeSafety/benchmark.py +++ b/clang/test/Analysis/LifetimeSafety/benchmark.py @@ -145,6 +145,60 @@ def generate_cpp_nested_loop_test(n: int) -> str: return cpp_code +def generate_cpp_switch_fan_out_test(n: int) -> str: + """ + Generates C++ code with a switch statement with N branches. + Each branch 'i' 'uses' (reads) a single, unique pointer 'pi'. + This pattern creates a "fan-in" join point for the backward + liveness analysis, stressing the LivenessMap::join operation + by forcing it to merge N disjoint, single-element sets of live origins. + The resulting complexity for LiveOrigins should be O(n log n) or higher. + + Example (n=3): + struct MyObj { int id; ~MyObj() {} }; + + void switch_fan_out_3(int condition) { + MyObj v1{1}; MyObj v2{1}; MyObj v3{1}; + MyObj* p1 = &v1; MyObj* p2 = &v2; MyObj* p3 = &v3; + + switch (condition % 3) { + case 0: + p1->id = 1; + break; + case 1: + p2->id = 1; + break; + case 2: + p3->id = 1; + break; + } + } + """ + if n <= 0: + return "// Number of variables must be positive." + + cpp_code = "struct MyObj { int id; ~MyObj() {} };\n\n" + cpp_code += f"void switch_fan_out{n}(int condition) {{\n" + # Generate N distinct objects + for i in range(1, n + 1): + cpp_code += f" MyObj v{i}{{1}};\n" + cpp_code += "\n" + # Generate N distinct pointers, each as a separate variable + for i in range(1, n + 1): + cpp_code += f" MyObj* p{i} = &v{i};\n" + cpp_code += "\n" + + cpp_code += f" switch (condition % {n}) {{\n" + for case_num in range(n): + cpp_code += f" case {case_num}:\n" + cpp_code += f" p{case_num + 1}->id = 1;\n" + cpp_code += " break;\n" + + cpp_code += " }\n}\n" + cpp_code += f"\nint main() {{ switch_fan_out{n}(0); return 0; }}\n" + return cpp_code + + def analyze_trace_file(trace_path: str) -> dict: """ Parses the -ftime-trace JSON output to find durations for the lifetime @@ -156,14 +210,14 @@ def analyze_trace_file(trace_path: str) -> dict: "total_us": 0.0, "fact_gen_us": 0.0, "loan_prop_us": 0.0, - "expired_loans_us": 0.0, + "live_origins_us": 0.0, } event_name_map = { "LifetimeSafetyAnalysis": "lifetime_us", "ExecuteCompiler": "total_us", "FactGenerator": "fact_gen_us", "LoanPropagation": "loan_prop_us", - "ExpiredLoans": "expired_loans_us", + "LiveOrigins": "live_origins_us", } try: with open(trace_path, "r") as f: @@ -227,7 +281,7 @@ def generate_markdown_report(results: dict) -> str: # Table header report.append( - "| N (Input Size) | Total Time | Analysis Time (%) | Fact Generator (%) | Loan Propagation (%) | Expired Loans (%) |" + "| N (Input Size) | Total Time | Analysis Time (%) | Fact Generator (%) | Loan Propagation (%) | Live Origins (%) |" ) report.append( "|:---------------|-----------:|------------------:|-------------------:|---------------------:|------------------:|" @@ -247,7 +301,7 @@ def generate_markdown_report(results: dict) -> str: f"{data['lifetime_ms'][i] / total_t * 100:>17.2f}% |", f"{data['fact_gen_ms'][i] / total_t * 100:>18.2f}% |", f"{data['loan_prop_ms'][i] / total_t * 100:>20.2f}% |", - f"{data['expired_loans_ms'][i] / total_t * 100:>17.2f}% |", + f"{data['live_origins_ms'][i] / total_t * 100:>17.2f}% |", ] report.append(" ".join(row)) @@ -259,7 +313,7 @@ def generate_markdown_report(results: dict) -> str: "Total Analysis": data["lifetime_ms"], "FactGenerator": data["fact_gen_ms"], "LoanPropagation": data["loan_prop_ms"], - "ExpiredLoans": data["expired_loans_ms"], + "LiveOrigins": data["live_origins_ms"], } for phase_name, y_data in analysis_phases.items(): @@ -302,7 +356,13 @@ def run_single_test( source_file, ] - result = subprocess.run(clang_command, capture_output=True, text=True, timeout=60) + try: + result = subprocess.run( + clang_command, capture_output=True, text=True, timeout=60 + ) + except subprocess.TimeoutExpired: + print(f"Compilation timed out for N={n}!", file=sys.stderr) + return {} if result.returncode != 0: print(f"Compilation failed for N={n}!", file=sys.stderr) @@ -354,6 +414,12 @@ if __name__ == "__main__": "generator_func": generate_cpp_nested_loop_test, "n_values": [50, 100, 150, 200], }, + { + "name": "switch_fan_out", + "title": "Switch Fan-out", + "generator_func": generate_cpp_switch_fan_out_test, + "n_values": [500, 1000, 2000, 4000], + }, ] results = {} @@ -368,7 +434,7 @@ if __name__ == "__main__": "total_ms": [], "fact_gen_ms": [], "loan_prop_ms": [], - "expired_loans_ms": [], + "live_origins_ms": [], } for n in config["n_values"]: durations_ms = run_single_test( @@ -387,7 +453,7 @@ if __name__ == "__main__": f" Total Analysis: {human_readable_time(durations_ms['lifetime_ms'])} | " f"FactGen: {human_readable_time(durations_ms['fact_gen_ms'])} | " f"LoanProp: {human_readable_time(durations_ms['loan_prop_ms'])} | " - f"ExpiredLoans: {human_readable_time(durations_ms['expired_loans_ms'])}" + f"LiveOrigins: {human_readable_time(durations_ms['live_origins_ms'])}" ) print("\n\n" + "=" * 80) diff --git a/clang/test/Analysis/NewDeleteLeaks.cpp b/clang/test/Analysis/NewDeleteLeaks.cpp index b2bad7e..d9c4b77 100644 --- a/clang/test/Analysis/NewDeleteLeaks.cpp +++ b/clang/test/Analysis/NewDeleteLeaks.cpp @@ -13,6 +13,8 @@ // RUN: unix.DynamicMemoryModeling:AddNoOwnershipChangeNotes=true #include "Inputs/system-header-simulator-for-malloc.h" +// For the tests in namespace protobuf_leak: +#include "Inputs/system-header-simulator-for-protobuf.h" //===----------------------------------------------------------------------===// // Report for which we expect NoOwnershipChangeVisitor to add a new note. @@ -218,3 +220,34 @@ void caller() { (void)n; } // no-warning: No potential memory leak here, because that's been already reported. } // namespace symbol_reaper_lifetime + +// Check that we do not report false positives in automatically generated +// protobuf code that passes dynamically allocated memory to a certain function +// named GetOwnedMessageInternal. +namespace protobuf_leak { +Arena *some_arena, *some_submessage_arena; + +MessageLite *protobuf_leak() { + MessageLite *p = new MessageLite(); // Real protobuf code instantiates a + // subclass of MessageLite, but that's + // not relevant for the bug. + MessageLite *q = GetOwnedMessageInternal(some_arena, p, some_submessage_arena); + return q; + // No leak at end of function -- the pointer escapes in GetOwnedMessageInternal. +} + +void validate_system_header() { + // The case protobuf_leak would also pass if GetOwnedMessageInternal wasn't + // declared in a system header. This test verifies that another function + // declared in the same header behaves differently (doesn't escape memory) to + // demonstrate that GetOwnedMessageInternal is indeed explicitly recognized + // by the analyzer. + + // expected-note@+1 {{Memory is allocated}} + MessageLite *p = new MessageLite(); + SomeOtherFunction(p); + // expected-warning@+2 {{Potential leak of memory pointed to by 'p'}} + // expected-note@+1 {{Potential leak of memory pointed to by 'p'}} +} + +} // namespace protobuf_leak diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp index 7afa955..844d4df 100644 --- a/clang/test/CIR/CodeGen/cast.cpp +++ b/clang/test/CIR/CodeGen/cast.cpp @@ -131,3 +131,36 @@ void bitcast() { // LLVM: %[[D_VEC:.*]] = load <2 x double>, ptr {{.*}}, align 16 // LLVM: %[[I_VEC:.*]] = bitcast <2 x double> %[[D_VEC]] to <4 x i32> + +void f(long int start) { + void *p = (void*)start; +} +// CIR: %[[L:.*]] = cir.load {{.*}} : !cir.ptr<!s64i>, !s64i +// CIR: %[[MID:.*]] = cir.cast integral %[[L]] : !s64i -> !u64i +// CIR: cir.cast int_to_ptr %[[MID]] : !u64i -> !cir.ptr<!void> + +// LLVM-LABEL: define{{.*}} void @_Z1fl(i64 %0) +// LLVM: %[[ADDR:.*]] = alloca i64, i64 1, align 8 +// LLVM: %[[PADDR:.*]] = alloca ptr, i64 1, align 8 +// LLVM: store i64 %0, ptr %[[ADDR]], align 8 +// LLVM: %[[L:.*]] = load i64, ptr %[[ADDR]], align 8 +// LLVM: %[[PTR:.*]] = inttoptr i64 %[[L]] to ptr +// LLVM: store ptr %[[PTR]], ptr %[[PADDR]], align 8 +// LLVM: ret void + +struct A { int x; }; + +void int_cast(long ptr) { + ((A *)ptr)->x = 0; +} +// CIR: cir.cast int_to_ptr {{.*}} : !u64i -> !cir.ptr<!rec_A> +// LLVM: inttoptr {{.*}} to ptr + +void null_cast(long) { + *(int *)0 = 0; + ((A *)0)->x = 0; +} +// CIR: %[[NULLPTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i> +// CIR: cir.store{{.*}} %{{.*}}, %[[NULLPTR]] : !s32i, !cir.ptr<!s32i> +// CIR: %[[NULLPTR_A:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_A> +// CIR: %[[A_X:.*]] = cir.get_member %[[NULLPTR_A]][0] {name = "x"} : !cir.ptr<!rec_A> -> !cir.ptr<!s32i> diff --git a/clang/test/CIR/CodeGen/complex.cpp b/clang/test/CIR/CodeGen/complex.cpp index 73c05b3..083d438 100644 --- a/clang/test/CIR/CodeGen/complex.cpp +++ b/clang/test/CIR/CodeGen/complex.cpp @@ -1359,3 +1359,49 @@ void complex_type_argument() { // OGCG: store float %[[A_IMAG]], ptr %[[ARG_IMAG_PTR]], align 4 // OGCG: %[[TMP_ARG:.*]] = load <2 x float>, ptr %[[ARG_ADDR]], align 4 // OGCG: call void @_Z22complex_type_parameterCf(<2 x float> noundef %[[TMP_ARG]]) + +void real_on_scalar_bool() { + bool a; + bool b = __real__ a; +} + +// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a"] +// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] +// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool +// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.bool -> !cir.bool +// CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool> + +// LLVM: %[[A_ADDR:.*]] = alloca i8, i64 1, align 1 +// LLVM: %[[B_ADDR:.*]] = alloca i8, i64 1, align 1 +// LLVM: %[[TMP_A:.*]] = load i8, ptr %[[A_ADDR]], align 1 +// LLVM: %[[TMP_A_I1:.*]] = trunc i8 %[[TMP_A]] to i1 +// LLVM: %[[TMP_A_I8:.*]] = zext i1 %[[TMP_A_I1]] to i8 +// LLVM: store i8 %[[TMP_A_I8]], ptr %[[B_ADDR]], align 1 + +// OGCG: %[[A_ADDR:.*]] = alloca i8, align 1 +// OGCG: %[[B_ADDR:.*]] = alloca i8, align 1 +// OGCG: %[[TMP_A:.*]] = load i8, ptr %[[A_ADDR]], align 1 +// OGCG: %[[TMP_A_I1:.*]] = trunc i8 %[[TMP_A]] to i1 +// OGCG: %[[TMP_A_I8:.*]] = zext i1 %[[TMP_A_I1]] to i8 +// OGCG: store i8 %[[TMP_A_I8]], ptr %[[B_ADDR]], align 1 + +void imag_on_scalar_bool() { + bool a; + bool b = __imag__ a; +} + +// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a"] +// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] +// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool +// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.bool -> !cir.bool +// CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool> + +// LLVM: %[[A_ADDR:.*]] = alloca i8, i64 1, align 1 +// LLVM: %[[B_ADDR:.*]] = alloca i8, i64 1, align 1 +// LLVM: %[[TMP_A:.*]] = load i8, ptr %[[A_ADDR]], align 1 +// LLVM: %[[TMP_A_I1:.*]] = trunc i8 %[[TMP_A]] to i1 +// LLVM: store i8 0, ptr %[[B_ADDR]], align 1 + +// OGCG: %[[A_ADDR:.*]] = alloca i8, align 1 +// OGCG: %[[B_ADDR:.*]] = alloca i8, align 1 +// OGCG: store i8 0, ptr %[[B_ADDR]], align 1 diff --git a/clang/test/CIR/CodeGen/constant-inits.cpp b/clang/test/CIR/CodeGen/constant-inits.cpp index c9153c91..d5a7bb9 100644 --- a/clang/test/CIR/CodeGen/constant-inits.cpp +++ b/clang/test/CIR/CodeGen/constant-inits.cpp @@ -30,6 +30,41 @@ struct simple { int a, b; }; +// Byte-aligned bitfields +struct byte_aligned_bitfields { + unsigned int a : 8; + unsigned int b : 8; + unsigned int c : 16; +}; + +struct signed_byte_aligned_bitfields { + int x : 8; + int y : 8; +}; + +struct single_byte_bitfield { + unsigned char a : 8; +}; + +// Partial bitfields (sub-byte) +struct partial_bitfields { + unsigned int a : 3; + unsigned int b : 5; + unsigned int c : 8; +}; + +struct signed_partial_bitfields { + int x : 4; + int y : 4; +}; + +struct mixed_partial_bitfields { + unsigned char a : 1; + unsigned char b : 1; + unsigned char c : 1; + unsigned char d : 5; +}; + void function() { constexpr static empty e; @@ -54,8 +89,22 @@ void function() { constexpr static simple simple_array[] { s, {1111, 2222}, s }; + + // Byte-aligned bitfield tests + constexpr static byte_aligned_bitfields ba_bf1 = {0xFF, 0xAA, 0x1234}; + constexpr static signed_byte_aligned_bitfields ba_bf2 = {-1, 127}; + constexpr static single_byte_bitfield ba_bf3 = {42}; + + // Partial bitfield tests + constexpr static partial_bitfields p_bf1 = {1, 2, 3}; + constexpr static signed_partial_bitfields p_bf2 = {-1, 7}; + constexpr static mixed_partial_bitfields p_bf3 = {1, 0, 1, 15}; } +// Anonymous struct type definitions for bitfields +// CIR-DAG: !rec_anon_struct = !cir.record<struct {!u8i, !u8i, !u8i, !u8i}> +// CIR-DAG: !rec_anon_struct1 = !cir.record<struct {!u8i, !u8i, !cir.array<!u8i x 2>}> + // CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE1e = #cir.zero : !rec_empty // CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE1s = #cir.const_record<{#cir.int<0> : !s32i, #cir.int<-1> : !s32i}> : !rec_simple // CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE2p1 = #cir.const_record<{#cir.int<10> : !s32i, #cir.int<20> : !s32i, #cir.const_array<[#cir.int<99> : !s8i, #cir.int<88> : !s8i, #cir.int<77> : !s8i]> : !cir.array<!s8i x 3>, #cir.int<40> : !s32i}> : !rec_Point @@ -83,6 +132,33 @@ void function() { // CIR-DAG-SAME: #cir.zero : !rec_packed_and_aligned // CIR-DAG-SAME: ]> : !cir.array<!rec_packed_and_aligned x 2> +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE6ba_bf1 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<255> : !u8i, +// CIR-DAG-SAME: #cir.int<170> : !u8i, +// CIR-DAG-SAME: #cir.int<52> : !u8i, +// CIR-DAG-SAME: #cir.int<18> : !u8i +// CIR-DAG-SAME: }> : !rec_anon_struct +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE6ba_bf2 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<255> : !u8i, +// CIR-DAG-SAME: #cir.int<127> : !u8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 2> +// CIR-DAG-SAME: }> : !rec_anon_struct1 +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE6ba_bf3 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<42> : !u8i +// CIR-DAG-SAME: }> : !rec_single_byte_bitfield +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE5p_bf1 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<17> : !u8i, +// CIR-DAG-SAME: #cir.int<3> : !u8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 2> +// CIR-DAG-SAME: }> : !rec_anon_struct1 +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE5p_bf2 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<127> : !u8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 3> +// CIR-DAG-SAME: }> : !rec_signed_partial_bitfields +// CIR-DAG: cir.global "private" internal dso_local @_ZZ8functionvE5p_bf3 = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<125> : !u8i +// CIR-DAG-SAME: }> : !rec_mixed_partial_bitfields + // CIR-LABEL: cir.func dso_local @_Z8functionv() // CIR: cir.return @@ -96,6 +172,12 @@ void function() { // LLVM-DAG: @_ZZ8functionvE3paa = internal global %struct.packed_and_aligned <{ i16 1, i8 2, float 3.000000e+00, i8 0 }> // LLVM-DAG: @_ZZ8functionvE5array = internal global [2 x %struct.Point] [%struct.Point { i32 123, i32 456, [3 x i8] c"\0B\16!", i32 789 }, %struct.Point { i32 10, i32 20, [3 x i8] zeroinitializer, i32 40 }] // LLVM-DAG: @_ZZ8functionvE9paa_array = internal global [2 x %struct.packed_and_aligned] [%struct.packed_and_aligned <{ i16 1, i8 2, float 3.000000e+00, i8 0 }>, %struct.packed_and_aligned zeroinitializer] +// LLVM-DAG: @_ZZ8functionvE6ba_bf1 = internal global { i8, i8, i8, i8 } { i8 -1, i8 -86, i8 52, i8 18 } +// LLVM-DAG: @_ZZ8functionvE6ba_bf2 = internal global { i8, i8, [2 x i8] } { i8 -1, i8 127, [2 x i8] zeroinitializer } +// LLVM-DAG: @_ZZ8functionvE6ba_bf3 = internal global %struct.single_byte_bitfield { i8 42 } +// LLVM-DAG: @_ZZ8functionvE5p_bf1 = internal global { i8, i8, [2 x i8] } { i8 17, i8 3, [2 x i8] zeroinitializer } +// LLVM-DAG: @_ZZ8functionvE5p_bf2 = internal global %struct.signed_partial_bitfields { i8 127, [3 x i8] zeroinitializer } +// LLVM-DAG: @_ZZ8functionvE5p_bf3 = internal global %struct.mixed_partial_bitfields { i8 125 } // LLVM-LABEL: define{{.*}} void @_Z8functionv // LLVM: ret void @@ -110,6 +192,12 @@ void function() { // OGCG-DAG: @_ZZ8functionvE3paa = internal constant %struct.packed_and_aligned <{ i16 1, i8 2, float 3.000000e+00, i8 undef }> // OGCG-DAG: @_ZZ8functionvE5array = internal constant [2 x %struct.Point] [%struct.Point { i32 123, i32 456, [3 x i8] c"\0B\16!", i32 789 }, %struct.Point { i32 10, i32 20, [3 x i8] zeroinitializer, i32 40 }] // OGCG-DAG: @_ZZ8functionvE9paa_array = internal constant [2 x %struct.packed_and_aligned] [%struct.packed_and_aligned <{ i16 1, i8 2, float 3.000000e+00, i8 undef }>, %struct.packed_and_aligned <{ i16 0, i8 0, float 0.000000e+00, i8 undef }>] +// OGCG-DAG: @_ZZ8functionvE6ba_bf1 = internal constant { i8, i8, i8, i8 } { i8 -1, i8 -86, i8 52, i8 18 } +// OGCG-DAG: @_ZZ8functionvE6ba_bf2 = internal constant { i8, i8, [2 x i8] } { i8 -1, i8 127, [2 x i8] undef } +// OGCG-DAG: @_ZZ8functionvE6ba_bf3 = internal constant %struct.single_byte_bitfield { i8 42 } +// OGCG-DAG: @_ZZ8functionvE5p_bf1 = internal constant { i8, i8, [2 x i8] } { i8 17, i8 3, [2 x i8] undef } +// OGCG-DAG: @_ZZ8functionvE5p_bf2 = internal constant %struct.signed_partial_bitfields { i8 127, [3 x i8] undef } +// OGCG-DAG: @_ZZ8functionvE5p_bf3 = internal constant %struct.mixed_partial_bitfields { i8 125 } // OGCG-LABEL: define{{.*}} void @_Z8functionv // OGCG: ret void diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp index 66554b7..49952a7 100644 --- a/clang/test/CIR/CodeGen/dtors.cpp +++ b/clang/test/CIR/CodeGen/dtors.cpp @@ -171,3 +171,40 @@ bool test_temp_and() { return make_temp(1) && make_temp(2); } // OGCG: br label %[[CLEANUP_DONE]] // OGCG: [[CLEANUP_DONE]]: // OGCG: call void @_ZN1BD2Ev(ptr {{.*}} %[[REF_TMP0]]) + +struct C { + ~C(); +}; + +struct D { + int n; + C c; + ~D() {} +}; + +// CIR: cir.func {{.*}} @_ZN1DD2Ev +// CIR: %[[C:.*]] = cir.get_member %{{.*}}[1] {name = "c"} +// CIR: cir.call @_ZN1CD1Ev(%[[C]]) + +// LLVM: define {{.*}} void @_ZN1DD2Ev +// LLVM: %[[C:.*]] = getelementptr %struct.D, ptr %{{.*}}, i32 0, i32 1 +// LLVM: call void @_ZN1CD1Ev(ptr %[[C]]) + +// This destructor is defined after the calling function in OGCG. + +void test_nested_dtor() { + D d; +} + +// CIR: cir.func{{.*}} @_Z16test_nested_dtorv() +// CIR: cir.call @_ZN1DD2Ev(%{{.*}}) + +// LLVM: define {{.*}} void @_Z16test_nested_dtorv() +// LLVM: call void @_ZN1DD2Ev(ptr %{{.*}}) + +// OGCG: define {{.*}} void @_Z16test_nested_dtorv() +// OGCG: call void @_ZN1DD2Ev(ptr {{.*}} %{{.*}}) + +// OGCG: define {{.*}} void @_ZN1DD2Ev +// OGCG: %[[C:.*]] = getelementptr inbounds i8, ptr %{{.*}}, i64 4 +// OGCG: call void @_ZN1CD1Ev(ptr {{.*}} %[[C]]) diff --git a/clang/test/CIR/CodeGen/global-init.cpp b/clang/test/CIR/CodeGen/global-init.cpp index 0c19e68..2afb5a5 100644 --- a/clang/test/CIR/CodeGen/global-init.cpp +++ b/clang/test/CIR/CodeGen/global-init.cpp @@ -1,9 +1,10 @@ // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir --mlir-print-ir-before=cir-lowering-prepare %s -o %t.cir 2> %t-before.cir // RUN: FileCheck --input-file=%t-before.cir %s --check-prefix=CIR-BEFORE-LPP // RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR - -// Note: The LoweringPrepare work isn't yet complete. We still need to create -// the global ctor list attribute. +// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t-cir.ll +// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM +// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll +// RUN: FileCheck --input-file=%t.ll %s --check-prefix=OGCG struct NeedsCtor { NeedsCtor(); @@ -15,6 +16,9 @@ NeedsCtor needsCtor; // CIR-BEFORE-LPP: %[[THIS:.*]] = cir.get_global @needsCtor : !cir.ptr<!rec_NeedsCtor> // CIR-BEFORE-LPP: cir.call @_ZN9NeedsCtorC1Ev(%[[THIS]]) : (!cir.ptr<!rec_NeedsCtor>) -> () +// CIR: module @{{.*}} attributes { +// CIR-SAME: cir.global_ctors = [#cir.global_ctor<"_GLOBAL__sub_I_[[FILENAME:.*]]", 65535>] + // CIR: cir.global external @needsCtor = #cir.zero : !rec_NeedsCtor // CIR: cir.func internal private @__cxx_global_var_init() { // CIR: %0 = cir.get_global @needsCtor : !cir.ptr<!rec_NeedsCtor> @@ -24,3 +28,22 @@ NeedsCtor needsCtor; // CIR: cir.call @__cxx_global_var_init() : () -> () // CIR: cir.return // CIR: } + +// LLVM: @needsCtor = global %struct.NeedsCtor zeroinitializer, align 1 +// LLVM: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @_GLOBAL__sub_I_[[FILENAME:.*]], ptr null }] +// LLVM: declare void @_ZN9NeedsCtorC1Ev(ptr) + +// LLVM: define internal void @__cxx_global_var_init() +// LLVM: call void @_ZN9NeedsCtorC1Ev(ptr @needsCtor) + +// LLVM: define void @_GLOBAL__sub_I_[[FILENAME]]() +// LLVM: call void @__cxx_global_var_init() + +// OGCG: @needsCtor = global %struct.NeedsCtor zeroinitializer, align 1 +// OGCG: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @_GLOBAL__sub_I_[[FILENAME:.*]], ptr null }] + +// OGCG: define internal void @__cxx_global_var_init() {{.*}} section ".text.startup" { +// OGCG: call void @_ZN9NeedsCtorC1Ev(ptr noundef nonnull align 1 dereferenceable(1) @needsCtor) + +// OGCG: define internal void @_GLOBAL__sub_I_[[FILENAME]]() {{.*}} section ".text.startup" { +// OGCG: call void @__cxx_global_var_init() diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp index 3dcf7af..000ea5b 100644 --- a/clang/test/CIR/CodeGen/new.cpp +++ b/clang/test/CIR/CodeGen/new.cpp @@ -180,3 +180,56 @@ void test_new_with_complex_type() { // OGCG: store float 1.000000e+00, ptr %[[COMPLEX_REAL_PTR]], align 8 // OGCG: store float 2.000000e+00, ptr %[[COMPLEX_IMAG_PTR]], align 4 // OGCG: store ptr %[[NEW_COMPLEX]], ptr %[[A_ADDR]], align 8 + +void t_new_constant_size() { + auto p = new double[16]; +} + +// In this test, NUM_ELEMENTS isn't used because no cookie is needed and there +// are no constructor calls needed. + +// CHECK: cir.func{{.*}} @_Z19t_new_constant_sizev() +// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>, ["p", init] {alignment = 8 : i64} +// CHECK: %[[#NUM_ELEMENTS:]] = cir.const #cir.int<16> : !u64i +// CHECK: %[[#ALLOCATION_SIZE:]] = cir.const #cir.int<128> : !u64i +// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[#ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void> +// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.double> +// CHECK: cir.store align(8) %[[TYPED_PTR]], %[[P_ADDR]] : !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>> +// CHECK: cir.return +// CHECK: } + +// LLVM: define{{.*}} void @_Z19t_new_constant_sizev +// LLVM: %[[P_ADDR:.*]] = alloca ptr, i64 1, align 8 +// LLVM: %[[CALL:.*]] = call ptr @_Znam(i64 128) +// LLVM: store ptr %[[CALL]], ptr %[[P_ADDR]], align 8 + +// OGCG: define{{.*}} void @_Z19t_new_constant_sizev +// OGCG: %[[P_ADDR:.*]] = alloca ptr, align 8 +// OGCG: %[[CALL:.*]] = call noalias noundef nonnull ptr @_Znam(i64 noundef 128) +// OGCG: store ptr %[[CALL]], ptr %[[P_ADDR]], align 8 + + +void t_new_multidim_constant_size() { + auto p = new double[2][3][4]; +} + +// As above, NUM_ELEMENTS isn't used. + +// CHECK: cir.func{{.*}} @_Z28t_new_multidim_constant_sizev() +// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>, !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>, ["p", init] {alignment = 8 : i64} +// CHECK: %[[#NUM_ELEMENTS:]] = cir.const #cir.int<24> : !u64i +// CHECK: %[[#ALLOCATION_SIZE:]] = cir.const #cir.int<192> : !u64i +// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[#ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void> +// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>> +// CHECK: cir.store align(8) %[[TYPED_PTR]], %[[P_ADDR]] : !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>, !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>> +// CHECK: } + +// LLVM: define{{.*}} void @_Z28t_new_multidim_constant_sizev +// LLVM: %[[P_ADDR:.*]] = alloca ptr, i64 1, align 8 +// LLVM: %[[CALL:.*]] = call ptr @_Znam(i64 192) +// LLVM: store ptr %[[CALL]], ptr %[[P_ADDR]], align 8 + +// OGCG: define{{.*}} void @_Z28t_new_multidim_constant_sizev +// OGCG: %[[P_ADDR:.*]] = alloca ptr, align 8 +// OGCG: %[[CALL:.*]] = call noalias noundef nonnull ptr @_Znam(i64 noundef 192) +// OGCG: store ptr %[[CALL]], ptr %[[P_ADDR]], align 8 diff --git a/clang/test/CIR/CodeGen/throws.cpp b/clang/test/CIR/CodeGen/throws.cpp index 0122f30..ff6aa62 100644 --- a/clang/test/CIR/CodeGen/throws.cpp +++ b/clang/test/CIR/CodeGen/throws.cpp @@ -5,7 +5,7 @@ // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -emit-llvm %s -o %t.ll // RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG -void foo() { +void rethrow() { throw; } @@ -18,7 +18,7 @@ void foo() { // OGCG: call void @__cxa_rethrow() // OGCG: unreachable -int foo1(int a, int b) { +int rethrow_from_block(int a, int b) { if (b == 0) throw; return a / b; @@ -83,3 +83,43 @@ int foo1(int a, int b) { // OGCG: %[[TMP_B:.*]] = load i32, ptr %[[B_ADDR]], align 4 // OGCG: %[[DIV_A_B:.*]] = sdiv i32 %[[TMP_A]], %[[TMP_B]] // OGCG: ret i32 %[[DIV_A_B]] + +void throw_scalar() { + throw 1; +} + +// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i> +// CIR: %[[EXCEPTION_VALUE:.*]] = cir.const #cir.int<1> : !s32i +// CIR: cir.store{{.*}} %[[EXCEPTION_VALUE]], %[[EXCEPTION_ADDR]] : !s32i, !cir.ptr<!s32i> +// CIR: cir.throw %[[EXCEPTION_ADDR]] : !cir.ptr<!s32i>, @_ZTIi +// CIR: cir.unreachable + +// LLVM: %[[EXCEPTION_ADDR:.*]] = call ptr @__cxa_allocate_exception(i64 4) +// LLVM: store i32 1, ptr %[[EXCEPTION_ADDR]], align 16 +// LLVM: call void @__cxa_throw(ptr %[[EXCEPTION_ADDR]], ptr @_ZTIi, ptr null) +// LLVM: unreachable + +// OGCG: %[[EXCEPTION_ADDR:.*]] = call ptr @__cxa_allocate_exception(i64 4) +// OGCG: store i32 1, ptr %[[EXCEPTION_ADDR]], align 16 +// OGCG: call void @__cxa_throw(ptr %[[EXCEPTION_ADDR]], ptr @_ZTIi, ptr null) +// OGCG: unreachable + +void paren_expr() { (throw 0, 1 + 2); } + +// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i> +// CIR: %[[EXCEPTION_VALUE:.*]] = cir.const #cir.int<0> : !s32i +// CIR: cir.store{{.*}} %[[EXCEPTION_VALUE]], %[[EXCEPTION_ADDR]] : !s32i, !cir.ptr<!s32i> +// CIR: cir.throw %[[EXCEPTION_ADDR]] : !cir.ptr<!s32i>, @_ZTIi +// CIR: cir.unreachable +// CIR: ^bb1: +// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i +// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i +// CIR: %[[ADD:.*]] = cir.binop(add, %[[CONST_1]], %[[CONST_2]]) nsw : !s32i + +// LLVM: %[[EXCEPTION_ADDR:.*]] = call ptr @__cxa_allocate_exception(i64 4) +// LLVM: store i32 0, ptr %[[EXCEPTION_ADDR]], align 16 +// LLVM: call void @__cxa_throw(ptr %[[EXCEPTION_ADDR]], ptr @_ZTIi, ptr null) + +// OGCG: %[[EXCEPTION_ADDR:.*]] = call ptr @__cxa_allocate_exception(i64 4) +// OGCG: store i32 0, ptr %[[EXCEPTION_ADDR]], align 16 +// OGCG: call void @__cxa_throw(ptr %[[EXCEPTION_ADDR]], ptr @_ZTIi, ptr null) diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp index e83e548..74cb567 100644 --- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp +++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp @@ -21,7 +21,7 @@ void do_things(unsigned A, unsigned B) { ; T TwoArr[5][5]; -#pragma acc parallel private(TwoArr[B][B]) +#pragma acc parallel private(TwoArr[A:B][A:B]) // CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init { // CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}): // CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64} @@ -30,7 +30,7 @@ void do_things(unsigned A, unsigned B) { ; #pragma acc parallel private(TwoArr[B][A:B]) ; -#pragma acc parallel private(TwoArr[A:B][A:B]) +#pragma acc parallel private(TwoArr[B][B]) ; #pragma acc parallel private(TwoArr) // CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init { diff --git a/clang/test/CIR/IR/dynamic-cast.cir b/clang/test/CIR/IR/dynamic-cast.cir new file mode 100644 index 0000000..283f11e --- /dev/null +++ b/clang/test/CIR/IR/dynamic-cast.cir @@ -0,0 +1,59 @@ +// RUN: cir-opt --verify-roundtrip %s | FileCheck %s + +!s64i = !cir.int<s, 64> +!u8i = !cir.int<u, 8> +!void = !cir.void + +!rec_Base = !cir.record<struct "Base" {!cir.vptr}> +!rec_Derived = !cir.record<struct "Derived" {!rec_Base}> + +#dyn_cast_info__ZTI4Base__ZTI7Derived = #cir.dyn_cast_info<src_rtti = #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>, dest_rtti = #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>, runtime_func = @__dynamic_cast, bad_cast_func = @__cxa_bad_cast, offset_hint = #cir.int<0> : !s64i> + +// CHECK: #dyn_cast_info__ZTI4Base__ZTI7Derived = #cir.dyn_cast_info<src_rtti = #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>, dest_rtti = #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>, runtime_func = @__dynamic_cast, bad_cast_func = @__cxa_bad_cast, offset_hint = #cir.int<0> : !s64i> + +module { + cir.global "private" constant external @_ZTI4Base : !cir.ptr<!u8i> + cir.global "private" constant external @_ZTI7Derived : !cir.ptr<!u8i> + cir.func private @__dynamic_cast(!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> + cir.func private @__cxa_bad_cast() + + cir.func @test_ptr_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!rec_Derived> { + %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived + cir.return %0 : !cir.ptr<!rec_Derived> + } + + // CHECK: cir.func @test_ptr_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!rec_Derived> { + // CHECK: %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived + // CHECK: cir.return %0 : !cir.ptr<!rec_Derived> + // CHECK: } + + cir.func @test_ref_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!rec_Derived> { + %0 = cir.dyn_cast ref %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived + cir.return %0 : !cir.ptr<!rec_Derived> + } + + // CHECK: cir.func @test_ref_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!rec_Derived> { + // CHECK: %0 = cir.dyn_cast ref %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived + // CHECK: cir.return %0 : !cir.ptr<!rec_Derived> + // CHECK: } + + cir.func dso_local @test_cast_to_void(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!void> { + %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!void> + cir.return %0 : !cir.ptr<!void> + } + + // CHECK: cir.func dso_local @test_cast_to_void(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!void> { + // CHECK: %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!void> + // CHECK: cir.return %0 : !cir.ptr<!void> + // CHECK: } + + cir.func dso_local @test_relative_layout_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!void> { + %0 = cir.dyn_cast ptr relative_layout %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!void> + cir.return %0 : !cir.ptr<!void> + } + + // CHECK: cir.func dso_local @test_relative_layout_cast(%arg0: !cir.ptr<!rec_Base>) -> !cir.ptr<!void> { + // CHECK: %0 = cir.dyn_cast ptr relative_layout %arg0 : !cir.ptr<!rec_Base> -> !cir.ptr<!void> + // CHECK: cir.return %0 : !cir.ptr<!void> + // CHECK: } +} diff --git a/clang/test/CIR/IR/invalid-dyn-cast.cir b/clang/test/CIR/IR/invalid-dyn-cast.cir new file mode 100644 index 0000000..65c7fc1 --- /dev/null +++ b/clang/test/CIR/IR/invalid-dyn-cast.cir @@ -0,0 +1,43 @@ +// RUN: cir-opt %s -verify-diagnostics -split-input-file + +!s64i = !cir.int<s, 64> +!s8i = !cir.int<s, 8> +!u32i = !cir.int<u, 32> +!u8i = !cir.int<u, 8> +!void = !cir.void + +!Base = !cir.record<struct "Base" {!cir.ptr<!cir.ptr<!cir.func<() -> !cir.int<u, 32>>>>}> +!Derived = !cir.record<struct "Derived" {!cir.record<struct "Base" {!cir.ptr<!cir.ptr<!cir.func<() -> !cir.int<u, 32>>>>}>}> + +module { + cir.global "private" constant external @_ZTI4Base : !cir.ptr<!u32i> + cir.global "private" constant external @_ZTI7Derived : !cir.ptr<!u8i> + cir.func private @__dynamic_cast(!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> + cir.func private @__cxa_bad_cast() + cir.func @test(%arg0 : !cir.ptr<!Base>) { + // expected-error@+1 {{srcRtti must be an RTTI pointer}} + %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!Base> -> !cir.ptr<!Derived> #cir.dyn_cast_info<src_rtti = #cir.global_view<@_ZTI4Base> : !cir.ptr<!u32i>, dest_rtti = #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>, runtime_func = @__dynamic_cast, bad_cast_func = @__cxa_bad_cast, offset_hint = #cir.int<0> : !s64i> + } +} + +// ----- + +!s64i = !cir.int<s, 64> +!s8i = !cir.int<s, 8> +!u32i = !cir.int<u, 32> +!u8i = !cir.int<u, 8> +!void = !cir.void + +!Base = !cir.record<struct "Base" {!cir.ptr<!cir.ptr<!cir.func<() -> !cir.int<u, 32>>>>}> +!Derived = !cir.record<struct "Derived" {!cir.record<struct "Base" {!cir.ptr<!cir.ptr<!cir.func<() -> !cir.int<u, 32>>>>}>}> + +module { + cir.global "private" constant external @_ZTI4Base : !cir.ptr<!u8i> + cir.global "private" constant external @_ZTI7Derived : !cir.ptr<!u32i> + cir.func private @__dynamic_cast(!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> + cir.func private @__cxa_bad_cast() + cir.func @test(%arg0 : !cir.ptr<!Base>) { + // expected-error@+1 {{destRtti must be an RTTI pointer}} + %0 = cir.dyn_cast ptr %arg0 : !cir.ptr<!Base> -> !cir.ptr<!Derived> #cir.dyn_cast_info<src_rtti = #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>, dest_rtti = #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u32i>, runtime_func = @__dynamic_cast, bad_cast_func = @__cxa_bad_cast, offset_hint = #cir.int<0> : !s64i> + } +} diff --git a/clang/test/CMakeLists.txt b/clang/test/CMakeLists.txt index e9f4f83..bcb6bd6 100644 --- a/clang/test/CMakeLists.txt +++ b/clang/test/CMakeLists.txt @@ -103,7 +103,6 @@ list(APPEND CLANG_TEST_DEPS clang-linker-wrapper clang-nvlink-wrapper clang-offload-bundler - clang-offload-packager clang-sycl-linker diagtool hmaptool @@ -173,6 +172,7 @@ if( NOT CLANG_BUILT_STANDALONE ) llvm-strip llvm-symbolizer llvm-windres + llvm-offload-binary obj2yaml opt split-file diff --git a/clang/test/CodeGen/AArch64/sve2-intrinsics/acle_sve2_rax1.c b/clang/test/CodeGen/AArch64/sve2-intrinsics/acle_sve2_rax1.c index 42bc37b..480d4e4 100644 --- a/clang/test/CodeGen/AArch64/sve2-intrinsics/acle_sve2_rax1.c +++ b/clang/test/CodeGen/AArch64/sve2-intrinsics/acle_sve2_rax1.c @@ -1,10 +1,9 @@ // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py -// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sve -target-feature +sve2 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sme -target-feature +sme2 -target-feature +sme2p1 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sve -target-feature +sve2 -target-feature +sme2p1 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sve -target-feature +sve2 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - -x c++ %s | FileCheck %s -check-prefix=CPP-CHECK -// RUN: %clang_cc1 -fclang-abi-compat=latest -DSVE_OVERLOADED_FORMS -triple aarch64 -target-feature +sve -target-feature +sve2 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s -// RUN: %clang_cc1 -fclang-abi-compat=latest -DSVE_OVERLOADED_FORMS -triple aarch64 -target-feature +sve -target-feature +sve2 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - -x c++ %s | FileCheck %s -check-prefix=CPP-CHECK +// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sve -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sme -target-feature +sme2p1 -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fclang-abi-compat=latest -triple aarch64 -target-feature +sve -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - -x c++ %s | FileCheck %s -check-prefix=CPP-CHECK +// RUN: %clang_cc1 -fclang-abi-compat=latest -DSVE_OVERLOADED_FORMS -triple aarch64 -target-feature +sve -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -fclang-abi-compat=latest -DSVE_OVERLOADED_FORMS -triple aarch64 -target-feature +sve -target-feature +sve-sha3 -O1 -Werror -Wall -emit-llvm -o - -x c++ %s | FileCheck %s -check-prefix=CPP-CHECK // REQUIRES: aarch64-registered-target diff --git a/clang/test/CodeGen/X86/avx2-builtins.c b/clang/test/CodeGen/X86/avx2-builtins.c index 4299b18..55f18f9 100644 --- a/clang/test/CodeGen/X86/avx2-builtins.c +++ b/clang/test/CodeGen/X86/avx2-builtins.c @@ -810,12 +810,14 @@ __m256i test_mm256_madd_epi16(__m256i a, __m256i b) { // CHECK: call <8 x i32> @llvm.x86.avx2.pmadd.wd(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) return _mm256_madd_epi16(a, b); } +TEST_CONSTEXPR(match_v8si(_mm256_madd_epi16((__m256i)(__v16hi){1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, (__m256i)(__v16hi){10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160}), 50, 250, 610, 1130, 1810, 2650, 3650, 4810)); __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_maddubs_epi16 // CHECK: call <16 x i16> @llvm.x86.avx2.pmadd.ub.sw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) return _mm256_maddubs_epi16(a, b); } +TEST_CONSTEXPR(match_v16hi(_mm256_maddubs_epi16((__m256i)(__v32qi){1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7,8}, (__m256i)(__v32qs){2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, -8}), 5, 18, 39, 68, 15, 42, 77, 120, -3, -14, -33, -60, -15, -42, -77, -120)); __m128i test_mm_maskload_epi32(int const *a, __m128i m) { // CHECK-LABEL: test_mm_maskload_epi32 diff --git a/clang/test/CodeGen/X86/avx512bw-builtins.c b/clang/test/CodeGen/X86/avx512bw-builtins.c index bd19363..af1c904 100644 --- a/clang/test/CodeGen/X86/avx512bw-builtins.c +++ b/clang/test/CodeGen/X86/avx512bw-builtins.c @@ -1650,35 +1650,46 @@ __m512i test_mm512_maddubs_epi16(__m512i __X, __m512i __Y) { // CHECK: @llvm.x86.avx512.pmaddubs.w.512 return _mm512_maddubs_epi16(__X,__Y); } +TEST_CONSTEXPR(match_v32hi(_mm512_maddubs_epi16((__m512i)(__v64qi){2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3}, (__m512i)(__v64qs){5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5}), -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5)); + __m512i test_mm512_mask_maddubs_epi16(__m512i __W, __mmask32 __U, __m512i __X, __m512i __Y) { // CHECK-LABEL: test_mm512_mask_maddubs_epi16 // CHECK: @llvm.x86.avx512.pmaddubs.w.512 // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} return _mm512_mask_maddubs_epi16(__W,__U,__X,__Y); } +TEST_CONSTEXPR(match_v32hi(_mm512_mask_maddubs_epi16((__m512i)(__v32hi){-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -32}, 0x0000FFFF, (__m512i)(__v64qi){2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3}, (__m512i)(__v64qs){5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5}), -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -32)); + __m512i test_mm512_maskz_maddubs_epi16(__mmask32 __U, __m512i __X, __m512i __Y) { // CHECK-LABEL: test_mm512_maskz_maddubs_epi16 // CHECK: @llvm.x86.avx512.pmaddubs.w.512 // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} return _mm512_maskz_maddubs_epi16(__U,__X,__Y); } +TEST_CONSTEXPR(match_v32hi(_mm512_maskz_maddubs_epi16(0x0000FFFF, (__m512i)(__v64qi){2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3}, (__m512i)(__v64qs){5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5, 5, -5}), -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)); + __m512i test_mm512_madd_epi16(__m512i __A, __m512i __B) { // CHECK-LABEL: test_mm512_madd_epi16 // CHECK: @llvm.x86.avx512.pmaddw.d.512 return _mm512_madd_epi16(__A,__B); } +TEST_CONSTEXPR(match_v16si(_mm512_madd_epi16((__m512i)(__v32hi){1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}, (__m512i)(__v32hi){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}), 3, 7, 22, 30, 9, 21, 44, 60, 3, 7, 22, 30, 9, 21, 44, 60)); + __m512i test_mm512_mask_madd_epi16(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: test_mm512_mask_madd_epi16 // CHECK: @llvm.x86.avx512.pmaddw.d.512 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} return _mm512_mask_madd_epi16(__W,__U,__A,__B); } +TEST_CONSTEXPR(match_v16si(_mm512_mask_madd_epi16((__m512i)(__v16si){100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600}, 0xF0F0, (__m512i)(__v32hi){1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}, (__m512i)(__v32hi){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}), 100, 200, 300, 400, 9, 21, 44, 60, 900, 1000, 1100, 1200, 9, 21, 44, 60)); + __m512i test_mm512_maskz_madd_epi16(__mmask16 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: test_mm512_maskz_madd_epi16 // CHECK: @llvm.x86.avx512.pmaddw.d.512 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} return _mm512_maskz_madd_epi16(__U,__A,__B); } +TEST_CONSTEXPR(match_v16si(_mm512_maskz_madd_epi16(0xF0F0, (__m512i)(__v32hi){1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}, (__m512i)(__v32hi){1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8}), 0, 0, 0, 0, 9, 21, 44, 60, 0, 0, 0, 0, 9, 21, 44, 60)); __m256i test_mm512_cvtsepi16_epi8(__m512i __A) { // CHECK-LABEL: test_mm512_cvtsepi16_epi8 diff --git a/clang/test/CodeGen/X86/avx512vlbw-builtins.c b/clang/test/CodeGen/X86/avx512vlbw-builtins.c index 1fe1ec0..c0e46de 100644 --- a/clang/test/CodeGen/X86/avx512vlbw-builtins.c +++ b/clang/test/CodeGen/X86/avx512vlbw-builtins.c @@ -1865,6 +1865,7 @@ __m128i test_mm_mask_maddubs_epi16(__m128i __W, __mmask8 __U, __m128i __X, __m12 // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_mask_maddubs_epi16(__W, __U, __X, __Y); } +TEST_CONSTEXPR(match_v8hi(_mm_mask_maddubs_epi16((__m128i)(__v8hi){1, 2, 3, 4, 5, 6, 7, 8}, 0x0F, (__m128i)(__v16qi){1, 1, 2, 2, 3, 3, 4, 4, 1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v16qs){2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -2, -2, -3, -3, -4, -4}), 5, 18, 39, 68, 5, 6, 7, 8)); __m128i test_mm_maskz_maddubs_epi16(__mmask8 __U, __m128i __X, __m128i __Y) { // CHECK-LABEL: test_mm_maskz_maddubs_epi16 @@ -1872,6 +1873,7 @@ __m128i test_mm_maskz_maddubs_epi16(__mmask8 __U, __m128i __X, __m128i __Y) { // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_maskz_maddubs_epi16(__U, __X, __Y); } +TEST_CONSTEXPR(match_v8hi(_mm_maskz_maddubs_epi16(0x0F, (__m128i)(__v16qi){1, 1, 2, 2, 3, 3, 4, 4, 1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v16qs){2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -2, -2, -3, -3, -4, -4}), 5, 18, 39, 68, 0, 0, 0, 0)); __m256i test_mm256_mask_maddubs_epi16(__m256i __W, __mmask16 __U, __m256i __X, __m256i __Y) { // CHECK-LABEL: test_mm256_mask_maddubs_epi16 @@ -1879,6 +1881,7 @@ __m256i test_mm256_mask_maddubs_epi16(__m256i __W, __mmask16 __U, __m256i __X, _ // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_mask_maddubs_epi16(__W, __U, __X, __Y); } +TEST_CONSTEXPR(match_v16hi(_mm256_mask_maddubs_epi16((__m256i)(__v16hi){-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16}, 0x00FF, (__m256i)(__v32qi){1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7,8}, (__m256i)(__v32qs){2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, -8}), 5, 18, 39, 68, 15, 42, 77, 120, -9, -10, -11, -12, -13, -14, -15, -16)); __m256i test_mm256_maskz_maddubs_epi16(__mmask16 __U, __m256i __X, __m256i __Y) { // CHECK-LABEL: test_mm256_maskz_maddubs_epi16 @@ -1886,6 +1889,7 @@ __m256i test_mm256_maskz_maddubs_epi16(__mmask16 __U, __m256i __X, __m256i __Y) // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_maddubs_epi16(__U, __X, __Y); } +TEST_CONSTEXPR(match_v16hi(_mm256_maskz_maddubs_epi16(0x00FF, (__m256i)(__v32qi){1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7,8}, (__m256i)(__v32qs){2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, -8}), 5, 18, 39, 68, 15, 42, 77, 120, 0, 0, 0, 0, 0, 0, 0, 0)); __m128i test_mm_mask_madd_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: test_mm_mask_madd_epi16 @@ -1893,6 +1897,7 @@ __m128i test_mm_mask_madd_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} return _mm_mask_madd_epi16(__W, __U, __A, __B); } +TEST_CONSTEXPR(match_v4si(_mm_mask_madd_epi16((__m128i)(__v4si){1, 2, 3, 4}, 0x3, (__m128i)(__v8hi){1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v8hi){9, 10, 11, 12, 13, 14, 15, 16}), 29, 81, 3, 4)); __m128i test_mm_maskz_madd_epi16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: test_mm_maskz_madd_epi16 @@ -1900,6 +1905,7 @@ __m128i test_mm_maskz_madd_epi16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} return _mm_maskz_madd_epi16(__U, __A, __B); } +TEST_CONSTEXPR(match_v4si(_mm_maskz_madd_epi16(0x3, (__m128i)(__v8hi){1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v8hi){9, 10, 11, 12, 13, 14, 15, 16}), 29, 81, 0, 0)); __m256i test_mm256_mask_madd_epi16(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: test_mm256_mask_madd_epi16 @@ -1907,6 +1913,7 @@ __m256i test_mm256_mask_madd_epi16(__m256i __W, __mmask8 __U, __m256i __A, __m25 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} return _mm256_mask_madd_epi16(__W, __U, __A, __B); } +TEST_CONSTEXPR(match_v8si(_mm256_mask_madd_epi16((__m256i)(__v8si){1, 2, 3, 4, 5, 6, 7, 8}, 0x0F, (__m256i)(__v16hi){1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, (__m256i)(__v16hi){10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160}), 50, 250, 610, 1130, 5, 6, 7, 8)); __m256i test_mm256_maskz_madd_epi16(__mmask8 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: test_mm256_maskz_madd_epi16 @@ -1914,6 +1921,7 @@ __m256i test_mm256_maskz_madd_epi16(__mmask8 __U, __m256i __A, __m256i __B) { // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} return _mm256_maskz_madd_epi16(__U, __A, __B); } +TEST_CONSTEXPR(match_v8si(_mm256_maskz_madd_epi16(0x0F, (__m256i)(__v16hi){1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, (__m256i)(__v16hi){10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160}), 50, 250, 610, 1130, 0, 0, 0, 0)); __m128i test_mm_cvtsepi16_epi8(__m128i __A) { // CHECK-LABEL: test_mm_cvtsepi16_epi8 diff --git a/clang/test/CodeGen/X86/avx512vlfp16-builtins.c b/clang/test/CodeGen/X86/avx512vlfp16-builtins.c index f1865aa..68d0984 100644 --- a/clang/test/CodeGen/X86/avx512vlfp16-builtins.c +++ b/clang/test/CodeGen/X86/avx512vlfp16-builtins.c @@ -17,12 +17,14 @@ _Float16 test_mm_cvtsh_h(__m128h __A) { // CHECK: extractelement <8 x half> %{{.*}}, i32 0 return _mm_cvtsh_h(__A); } +TEST_CONSTEXPR(_mm_cvtsh_h((__m128h){-8.0, 7.0, -6.0, 5.0, -4.0, 3.0, -2.0, 1.0}) == -8.0); _Float16 test_mm256_cvtsh_h(__m256h __A) { // CHECK-LABEL: test_mm256_cvtsh_h // CHECK: extractelement <16 x half> %{{.*}}, i32 0 return _mm256_cvtsh_h(__A); } +TEST_CONSTEXPR(_mm256_cvtsh_h((__m256h){-32.0, 31.0, -30.0, 29.0, -28.0, 27.0, -26.0, 25.0, -24.0, 23.0, -22.0, 21.0, -20.0, 19.0, -18.0, 17.0}) == -32.0); __m128h test_mm_set_sh(_Float16 __h) { // CHECK-LABEL: test_mm_set_sh diff --git a/clang/test/CodeGen/X86/mmx-builtins.c b/clang/test/CodeGen/X86/mmx-builtins.c index a4494b69..2b45b92 100644 --- a/clang/test/CodeGen/X86/mmx-builtins.c +++ b/clang/test/CodeGen/X86/mmx-builtins.c @@ -355,12 +355,14 @@ __m64 test_mm_madd_pi16(__m64 a, __m64 b) { // CHECK: call <4 x i32> @llvm.x86.sse2.pmadd.wd( return _mm_madd_pi16(a, b); } +TEST_CONSTEXPR(match_v2si(_mm_madd_pi16((__m64)(__v4hi){+1, -2, +3, -4}, (__m64)(__v4hi){-10, +8, +6, -4}), -26, 34)); __m64 test_mm_maddubs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_maddubs_pi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.pmadd.ub.sw.128( return _mm_maddubs_pi16(a, b); } +TEST_CONSTEXPR(match_v4hi(_mm_maddubs_pi16((__m64)(__v8qi){16, 17, 18, 19, 20, 21, 22, 23}, (__m64)(__v8qi){1, 2, 3, 4, 5, 0, 7, 8}), 50, 130, 100, 338)); void test_mm_maskmove_si64(__m64 d, __m64 n, char *p) { // CHECK-LABEL: test_mm_maskmove_si64 diff --git a/clang/test/CodeGen/X86/sse2-builtins.c b/clang/test/CodeGen/X86/sse2-builtins.c index 8428fd6..ade7ef3 100644 --- a/clang/test/CodeGen/X86/sse2-builtins.c +++ b/clang/test/CodeGen/X86/sse2-builtins.c @@ -852,6 +852,7 @@ __m128i test_mm_madd_epi16(__m128i A, __m128i B) { // CHECK: call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_madd_epi16(A, B); } +TEST_CONSTEXPR(match_v4si(_mm_madd_epi16((__m128i)(__v8hi){1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v8hi){9, 10, 11, 12, 13, 14, 15, 16}), 29, 81, 149, 233)); void test_mm_maskmoveu_si128(__m128i A, __m128i B, char* C) { // CHECK-LABEL: test_mm_maskmoveu_si128 diff --git a/clang/test/CodeGen/X86/ssse3-builtins.c b/clang/test/CodeGen/X86/ssse3-builtins.c index 56ff73f0..5885768 100644 --- a/clang/test/CodeGen/X86/ssse3-builtins.c +++ b/clang/test/CodeGen/X86/ssse3-builtins.c @@ -96,6 +96,7 @@ __m128i test_mm_maddubs_epi16(__m128i a, __m128i b) { // CHECK: call <8 x i16> @llvm.x86.ssse3.pmadd.ub.sw.128(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) return _mm_maddubs_epi16(a, b); } +TEST_CONSTEXPR(match_v8hi(_mm_maddubs_epi16((__m128i)(__v16qi){1, 1, 2, 2, 3, 3, 4, 4, 1, 2, 3, 4, 5, 6, 7, 8}, (__m128i)(__v16qs){2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -2, -2, -3, -3, -4, -4}), 5, 18, 39, 68, -3, -14, -33, -60)); __m128i test_mm_mulhrs_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_mulhrs_epi16 diff --git a/clang/test/CodeGen/alloc-token-ignorelist.c b/clang/test/CodeGen/alloc-token-ignorelist.c new file mode 100644 index 0000000..954e6e5 --- /dev/null +++ b/clang/test/CodeGen/alloc-token-ignorelist.c @@ -0,0 +1,27 @@ +// Test AllocToken respects ignorelist for functions and files. +// +// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-ALLOW +// +// RUN: echo "fun:excluded_by_all" > %t.func.ignorelist +// RUN: %clang_cc1 -fsanitize=alloc-token -fsanitize-ignorelist=%t.func.ignorelist -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-FUN +// +// RUN: echo "src:%s" | sed -e 's/\\/\\\\/g' > %t.file.ignorelist +// RUN: %clang_cc1 -fsanitize=alloc-token -fsanitize-ignorelist=%t.file.ignorelist -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-SRC + +extern void* malloc(unsigned long size); + +// CHECK-LABEL: define{{.*}} @excluded_by_all( +void* excluded_by_all(unsigned long size) { + // CHECK-ALLOW: call ptr @__alloc_token_malloc( + // CHECK-FUN: call ptr @malloc( + // CHECK-SRC: call ptr @malloc( + return malloc(size); +} + +// CHECK-LABEL: define{{.*}} @excluded_by_src( +void* excluded_by_src(unsigned long size) { + // CHECK-ALLOW: call ptr @__alloc_token_malloc( + // CHECK-FUN: call ptr @__alloc_token_malloc( + // CHECK-SRC: call ptr @malloc( + return malloc(size); +} diff --git a/clang/test/CodeGen/alloc-token-lower.c b/clang/test/CodeGen/alloc-token-lower.c new file mode 100644 index 0000000..75197bb --- /dev/null +++ b/clang/test/CodeGen/alloc-token-lower.c @@ -0,0 +1,22 @@ +// Test optimization pipelines do not interfere with AllocToken lowering, and we +// pass on function attributes correctly. +// +// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -O1 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -O2 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s + +typedef __typeof(sizeof(int)) size_t; + +void *malloc(size_t size); + +// CHECK-LABEL: @test_malloc( +// CHECK: call{{.*}} ptr @__alloc_token_malloc(i64 noundef 4, i64 0) +void *test_malloc() { + return malloc(sizeof(int)); +} + +// CHECK-LABEL: @no_sanitize_malloc( +// CHECK: call{{.*}} ptr @malloc(i64 noundef 4) +void *no_sanitize_malloc(size_t size) __attribute__((no_sanitize("alloc-token"))) { + return malloc(sizeof(int)); +} diff --git a/clang/test/CodeGen/alloc-token.c b/clang/test/CodeGen/alloc-token.c new file mode 100644 index 0000000..d1160ad --- /dev/null +++ b/clang/test/CodeGen/alloc-token.c @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s + +typedef __typeof(sizeof(int)) size_t; + +void *aligned_alloc(size_t alignment, size_t size); +void *malloc(size_t size); +void *calloc(size_t num, size_t size); +void *realloc(void *ptr, size_t size); +void *reallocarray(void *ptr, size_t nmemb, size_t size); +void *memalign(size_t alignment, size_t size); +void *valloc(size_t size); +void *pvalloc(size_t size); +int posix_memalign(void **memptr, size_t alignment, size_t size); + +void *sink; + +// CHECK-LABEL: define dso_local void @test_malloc_like( +// CHECK: call ptr @malloc(i64 noundef 4) +// CHECK: call ptr @calloc(i64 noundef 3, i64 noundef 4) +// CHECK: call ptr @realloc(ptr noundef {{.*}}, i64 noundef 8) +// CHECK: call ptr @reallocarray(ptr noundef {{.*}}, i64 noundef 5, i64 noundef 8) +// CHECK: call align 128 ptr @aligned_alloc(i64 noundef 128, i64 noundef 1024) +// CHECK: call align 16 ptr @memalign(i64 noundef 16, i64 noundef 256) +// CHECK: call ptr @valloc(i64 noundef 4096) +// CHECK: call ptr @pvalloc(i64 noundef 8192) +// CHECK: call i32 @posix_memalign(ptr noundef @sink, i64 noundef 64, i64 noundef 4) +void test_malloc_like() { + sink = malloc(sizeof(int)); + sink = calloc(3, sizeof(int)); + sink = realloc(sink, sizeof(long)); + sink = reallocarray(sink, 5, sizeof(long)); + sink = aligned_alloc(128, 1024); + sink = memalign(16, 256); + sink = valloc(4096); + sink = pvalloc(8192); + posix_memalign(&sink, 64, sizeof(int)); +} diff --git a/clang/test/CodeGen/catch-nullptr-and-nonzero-offset.c b/clang/test/CodeGen/catch-nullptr-and-nonzero-offset.c index 26d17e7..3dd8a36 100644 --- a/clang/test/CodeGen/catch-nullptr-and-nonzero-offset.c +++ b/clang/test/CodeGen/catch-nullptr-and-nonzero-offset.c @@ -25,12 +25,6 @@ // CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_500:.*]] = {{.*}}, i32 500, i32 15 } } // CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_700:.*]] = {{.*}}, i32 700, i32 15 } } // CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_800:.*]] = {{.*}}, i32 800, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_900:.*]] = {{.*}}, i32 900, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1100:.*]] = {{.*}}, i32 1100, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1200:.*]] = {{.*}}, i32 1200, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1300:.*]] = {{.*}}, i32 1300, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1500:.*]] = {{.*}}, i32 1500, i32 15 } } -// CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1600:.*]] = {{.*}}, i32 1600, i32 15 } } // CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1700:.*]] = {{.*}}, i32 1700, i32 15 } } // CHECK-SANITIZE-ANYRECOVER-DAG: @[[LINE_1800:.*]] = {{.*}}, i32 1800, i32 20 } } @@ -225,172 +219,6 @@ char *nullptr_allones_BAD(void) { //------------------------------------------------------------------------------ -char *one_var(unsigned long offset) { - // CHECK: define{{.*}} ptr @one_var(i64 noundef %[[OFFSET:.*]]) - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-NEXT: %[[OFFSET_ADDR:.*]] = alloca i64, align 8 - // CHECK-NEXT: store i64 %[[OFFSET]], ptr %[[OFFSET_ADDR]], align 8 - // CHECK-NEXT: %[[OFFSET_RELOADED:.*]] = load i64, ptr %[[OFFSET_ADDR]], align 8 - // CHECK-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds nuw i8, ptr inttoptr (i64 1 to ptr), i64 %[[OFFSET_RELOADED]] - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_AGGREGATE:.*]] = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 1, i64 %[[OFFSET_RELOADED]]), !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_OVERFLOWED:.*]] = extractvalue { i64, i1 } %[[COMPUTED_OFFSET_AGGREGATE]], 1, !nosanitize - // CHECK-SANITIZE-NEXT: %[[OR_OV:.+]] = or i1 %[[COMPUTED_OFFSET_OVERFLOWED]], false, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET:.*]] = extractvalue { i64, i1 } %[[COMPUTED_OFFSET_AGGREGATE]], 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP:.*]] = add i64 1, %[[COMPUTED_OFFSET]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[OTHER_IS_NOT_NULL:.*]] = icmp ne ptr inttoptr (i64 1 to ptr), null - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP_IS_NOT_NULL:.*]] = icmp ne i64 %[[COMPUTED_GEP]], 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[BOTH_POINTERS_ARE_NULL_OR_BOTH_ARE_NONNULL:.*]] = icmp eq i1 %[[OTHER_IS_NOT_NULL]], %[[COMPUTED_GEP_IS_NOT_NULL]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_DID_NOT_OVERFLOW:.*]] = xor i1 %[[OR_OV]], true, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP_IS_UGE_BASE:.*]] = icmp uge i64 %[[COMPUTED_GEP]], 1, !nosanitize - // CHECK-SANITIZE-NEXT: %[[GEP_DID_NOT_OVERFLOW:.*]] = and i1 %[[COMPUTED_GEP_IS_UGE_BASE]], %[[COMPUTED_OFFSET_DID_NOT_OVERFLOW]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[GEP_IS_OKAY:.*]] = and i1 %[[BOTH_POINTERS_ARE_NULL_OR_BOTH_ARE_NONNULL]], %[[GEP_DID_NOT_OVERFLOW]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[GEP_IS_OKAY]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_900]], i64 1, i64 %[[COMPUTED_GEP]]) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_900]], i64 1, i64 %[[COMPUTED_GEP]]) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr %[[ADD_PTR]] - static char *const base = (char *)1; -#line 900 - return base + offset; -} - -char *one_zero(void) { - // CHECK: define{{.*}} ptr @one_zero() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-NEXT: ret ptr inttoptr (i64 1 to ptr) - static char *const base = (char *)1; - static const unsigned long offset = 0; -#line 1000 - return base + offset; -} - -char *one_one_OK(void) { - // CHECK: define{{.*}} ptr @one_one_OK() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-SANITIZE-NEXT: %[[CMP1:.*]] = icmp ne ptr inttoptr (i64 1 to ptr), null, !nosanitize - // CHECK-SANITIZE-NEXT: %[[CMP2:.*]] = icmp ne i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 1) to i64), i64 1), i64 1), 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COND:.*]] = icmp eq i1 %[[CMP1]], %[[CMP2]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[COND]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_1100]], i64 1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 1) to i64), i64 1), i64 1)) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_1100]], i64 1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 1) to i64), i64 1), i64 1)) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 1) - static char *const base = (char *)1; - static const unsigned long offset = 1; -#line 1100 - return base + offset; -} - -char *one_allones_BAD(void) { - // CHECK: define{{.*}} ptr @one_allones_BAD() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-SANITIZE-NEXT: %[[CMP1:.*]] = icmp ne ptr inttoptr (i64 1 to ptr), null, !nosanitize - // CHECK-SANITIZE-NEXT: %[[CMP2:.*]] = icmp ne i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 -1) to i64), i64 1), i64 1), 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COND:.*]] = icmp eq i1 %[[CMP1]], %[[CMP2]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[COND]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_1200]], i64 1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 -1) to i64), i64 1), i64 1)) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_1200]], i64 1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 -1) to i64), i64 1), i64 1)) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 1 to ptr), i64 -1) - static char *const base = (char *)1; - static const unsigned long offset = -1; -#line 1200 - return base + offset; -} - -//------------------------------------------------------------------------------ - -char *allones_var(unsigned long offset) { - // CHECK: define{{.*}} ptr @allones_var(i64 noundef %[[OFFSET:.*]]) - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-NEXT: %[[OFFSET_ADDR:.*]] = alloca i64, align 8 - // CHECK-NEXT: store i64 %[[OFFSET]], ptr %[[OFFSET_ADDR]], align 8 - // CHECK-NEXT: %[[OFFSET_RELOADED:.*]] = load i64, ptr %[[OFFSET_ADDR]], align 8 - // CHECK-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds nuw i8, ptr inttoptr (i64 -1 to ptr), i64 %[[OFFSET_RELOADED]] - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_AGGREGATE:.*]] = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 1, i64 %[[OFFSET_RELOADED]]), !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_OVERFLOWED:.*]] = extractvalue { i64, i1 } %[[COMPUTED_OFFSET_AGGREGATE]], 1, !nosanitize - // CHECK-SANITIZE-NEXT: %[[OR_OV:.+]] = or i1 %[[COMPUTED_OFFSET_OVERFLOWED]], false, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET:.*]] = extractvalue { i64, i1 } %[[COMPUTED_OFFSET_AGGREGATE]], 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP:.*]] = add i64 -1, %[[COMPUTED_OFFSET]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[OTHER_IS_NOT_NULL:.*]] = icmp ne ptr inttoptr (i64 -1 to ptr), null, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP_IS_NOT_NULL:.*]] = icmp ne i64 %[[COMPUTED_GEP]], 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[BOTH_POINTERS_ARE_NULL_OR_BOTH_ARE_NONNULL:.*]] = icmp eq i1 %[[OTHER_IS_NOT_NULL]], %[[COMPUTED_GEP_IS_NOT_NULL]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_OFFSET_DID_NOT_OVERFLOW:.*]] = xor i1 %[[OR_OV]], true, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COMPUTED_GEP_IS_UGE_BASE:.*]] = icmp uge i64 %[[COMPUTED_GEP]], -1, !nosanitize - // CHECK-SANITIZE-NEXT: %[[GEP_DID_NOT_OVERFLOW:.*]] = and i1 %[[COMPUTED_GEP_IS_UGE_BASE]], %[[COMPUTED_OFFSET_DID_NOT_OVERFLOW]], !nosanitize - // CHECK-SANITIZE-NEXT: %[[GEP_IS_OKAY:.*]] = and i1 %[[BOTH_POINTERS_ARE_NULL_OR_BOTH_ARE_NONNULL]], %[[GEP_DID_NOT_OVERFLOW]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[GEP_IS_OKAY]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_1300]], i64 -1, i64 %[[COMPUTED_GEP]]) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_1300]], i64 -1, i64 %[[COMPUTED_GEP]]) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr %[[ADD_PTR]] - static char *const base = (char *)-1; -#line 1300 - return base + offset; -} - -char *allones_zero_OK(void) { - // CHECK: define{{.*}} ptr @allones_zero_OK() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-NEXT: ret ptr inttoptr (i64 -1 to ptr) - static char *const base = (char *)-1; - static const unsigned long offset = 0; -#line 1400 - return base + offset; -} - -char *allones_one_BAD(void) { - // CHECK: define{{.*}} ptr @allones_one_BAD() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-SANITIZE-NEXT: %[[CMP1:.*]] = icmp ne ptr inttoptr (i64 -1 to ptr), null, !nosanitize - // CHECK-SANITIZE-NEXT: %[[CMP2:.*]] = icmp ne i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 1) to i64), i64 -1), i64 -1), 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COND:.*]] = icmp eq i1 %[[CMP1]], %[[CMP2]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[COND]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_1500]], i64 -1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 1) to i64), i64 -1), i64 -1)) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_1500]], i64 -1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 1) to i64), i64 -1), i64 -1)) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 1) - static char *const base = (char *)-1; - static const unsigned long offset = 1; -#line 1500 - return base + offset; -} - -char *allones_allones_OK(void) { - // CHECK: define{{.*}} ptr @allones_allones_OK() - // CHECK-NEXT: [[ENTRY:.*]]: - // CHECK-SANITIZE-NEXT: %[[CMP1:.*]] = icmp ne ptr inttoptr (i64 -1 to ptr), null, !nosanitize - // CHECK-SANITIZE-NEXT: %[[CMP2:.*]] = icmp ne i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 -1) to i64), i64 -1), i64 -1), 0, !nosanitize - // CHECK-SANITIZE-NEXT: %[[COND:.*]] = icmp eq i1 %[[CMP1]], %[[CMP2]], !nosanitize - // CHECK-SANITIZE-NEXT: br i1 %[[COND]], label %[[CONT:.*]], label %[[HANDLER_POINTER_OVERFLOW:[^,]+]],{{.*}} !nosanitize - // CHECK-SANITIZE: [[HANDLER_POINTER_OVERFLOW]]: - // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_pointer_overflow_abort(ptr @[[LINE_1600]], i64 -1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 -1) to i64), i64 -1), i64 -1)) - // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_pointer_overflow(ptr @[[LINE_1600]], i64 -1, i64 add (i64 sub (i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 -1) to i64), i64 -1), i64 -1)) - // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 19){{.*}}, !nosanitize - // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize - // CHECK-SANITIZE: [[CONT]]: - // CHECK-NEXT: ret ptr getelementptr inbounds nuw (i8, ptr inttoptr (i64 -1 to ptr), i64 -1) - static char *const base = (char *)-1; - static const unsigned long offset = -1; -#line 1600 - return base + offset; -} - // C++ does not allow void* arithmetic even as a GNU extension. Replace void* // with char* in that case to keep test expectations the same. #ifdef __cplusplus diff --git a/clang/test/CodeGen/dwarf-version.c b/clang/test/CodeGen/dwarf-version.c index 258c258..500f66c 100644 --- a/clang/test/CodeGen/dwarf-version.c +++ b/clang/test/CodeGen/dwarf-version.c @@ -2,6 +2,7 @@ // RUN: %clang -target x86_64-linux-gnu -gdwarf-3 -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER3 // RUN: %clang -target x86_64-linux-gnu -gdwarf-4 -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER4 // RUN: %clang -target x86_64-linux-gnu -gdwarf-5 -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER5 +// RUN: %clang -target x86_64-linux-gnu -gdwarf-6 -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER6 // RUN: %clang -target x86_64-linux-gnu -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER5 // RUN: %clang -target x86_64-linux-gnu -gdwarf -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER5 // RUN: %clang --target=i386-pc-solaris -g -S -emit-llvm -o - %s | FileCheck %s --check-prefix=VER5 @@ -61,6 +62,7 @@ int main (void) { // VER3: !{i32 7, !"Dwarf Version", i32 3} // VER4: !{i32 7, !"Dwarf Version", i32 4} // VER5: !{i32 7, !"Dwarf Version", i32 5} +// VER6: !{i32 7, !"Dwarf Version", i32 6} // UNSUPPORTED-VER5: error: unsupported option '-gdwarf-5' // NODWARF-NOT: !"Dwarf Version" diff --git a/clang/test/CodeGenCXX/alloc-token.cpp b/clang/test/CodeGenCXX/alloc-token.cpp new file mode 100644 index 0000000..52bad9c --- /dev/null +++ b/clang/test/CodeGenCXX/alloc-token.cpp @@ -0,0 +1,141 @@ +// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -std=c++20 -fexceptions -fcxx-exceptions -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s + +#include "../Analysis/Inputs/system-header-simulator-cxx.h" +extern "C" { +void *aligned_alloc(size_t alignment, size_t size); +void *malloc(size_t size); +void *calloc(size_t num, size_t size); +void *realloc(void *ptr, size_t size); +void *reallocarray(void *ptr, size_t nmemb, size_t size); +void *memalign(size_t alignment, size_t size); +void *valloc(size_t size); +void *pvalloc(size_t size); +int posix_memalign(void **memptr, size_t alignment, size_t size); + +struct __sized_ptr_t { + void *p; + size_t n; +}; +enum class __hot_cold_t : uint8_t; +__sized_ptr_t __size_returning_new(size_t size); +__sized_ptr_t __size_returning_new_hot_cold(size_t, __hot_cold_t); +__sized_ptr_t __size_returning_new_aligned(size_t, std::align_val_t); +__sized_ptr_t __size_returning_new_aligned_hot_cold(size_t, std::align_val_t, __hot_cold_t); +} + +void *sink; // prevent optimizations from removing the calls + +// CHECK-LABEL: define dso_local void @_Z16test_malloc_likev( +// CHECK: call ptr @malloc(i64 noundef 4) +// CHECK: call ptr @calloc(i64 noundef 3, i64 noundef 4) +// CHECK: call ptr @realloc(ptr noundef {{.*}}, i64 noundef 8) +// CHECK: call ptr @reallocarray(ptr noundef {{.*}}, i64 noundef 5, i64 noundef 8) +// CHECK: call align 128 ptr @aligned_alloc(i64 noundef 128, i64 noundef 1024) +// CHECK: call ptr @memalign(i64 noundef 16, i64 noundef 256) +// CHECK: call ptr @valloc(i64 noundef 4096) +// CHECK: call ptr @pvalloc(i64 noundef 8192) +// CHECK: call i32 @posix_memalign(ptr noundef @sink, i64 noundef 64, i64 noundef 4) +void test_malloc_like() { + sink = malloc(sizeof(int)); + sink = calloc(3, sizeof(int)); + sink = realloc(sink, sizeof(long)); + sink = reallocarray(sink, 5, sizeof(long)); + sink = aligned_alloc(128, 1024); + sink = memalign(16, 256); + sink = valloc(4096); + sink = pvalloc(8192); + posix_memalign(&sink, 64, sizeof(int)); +} + +// CHECK-LABEL: define dso_local void @_Z17test_operator_newv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) +void test_operator_new() { + sink = __builtin_operator_new(sizeof(int)); + sink = ::operator new(sizeof(int)); +} + +// CHECK-LABEL: define dso_local void @_Z25test_operator_new_nothrowv( +// CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t(i64 noundef 4, ptr noundef nonnull align 1 dereferenceable(1) @_ZSt7nothrow) +// CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t(i64 noundef 4, ptr noundef nonnull align 1 dereferenceable(1) @_ZSt7nothrow) +void test_operator_new_nothrow() { + sink = __builtin_operator_new(sizeof(int), std::nothrow); + sink = ::operator new(sizeof(int), std::nothrow); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z8test_newv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4){{.*}} !alloc_token [[META_INT:![0-9]+]] +int *test_new() { + return new int; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z14test_new_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 40){{.*}} !alloc_token [[META_INT]] +int *test_new_array() { + return new int[10]; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z16test_new_nothrowv( +// CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t(i64 noundef 4, ptr noundef nonnull align 1 dereferenceable(1) @_ZSt7nothrow){{.*}} !alloc_token [[META_INT]] +int *test_new_nothrow() { + return new (std::nothrow) int; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z22test_new_array_nothrowv( +// CHECK: call noalias noundef ptr @_ZnamRKSt9nothrow_t(i64 noundef 40, ptr noundef nonnull align 1 dereferenceable(1) @_ZSt7nothrow){{.*}} !alloc_token [[META_INT]] +int *test_new_array_nothrow() { + return new (std::nothrow) int[10]; +} + +// CHECK-LABEL: define dso_local void @_Z23test_size_returning_newv( +// CHECK: call { ptr, i64 } @__size_returning_new(i64 noundef 8) +// CHECK: call { ptr, i64 } @__size_returning_new_hot_cold(i64 noundef 8, i8 noundef zeroext 1) +// CHECK: call { ptr, i64 } @__size_returning_new_aligned(i64 noundef 8, i64 noundef 32) +// CHECK: call { ptr, i64 } @__size_returning_new_aligned_hot_cold(i64 noundef 8, i64 noundef 32, i8 noundef zeroext 1) +void test_size_returning_new() { + sink = __size_returning_new(sizeof(long)).p; + sink = __size_returning_new_hot_cold(sizeof(long), __hot_cold_t{1}).p; + sink = __size_returning_new_aligned(sizeof(long), std::align_val_t{32}).p; + sink = __size_returning_new_aligned_hot_cold(sizeof(long), std::align_val_t{32}, __hot_cold_t{1}).p; +} + +class TestClass { +public: + virtual void Foo(); + virtual ~TestClass(); + int data[16]; +}; + +void may_throw(); + +// CHECK-LABEL: define dso_local noundef ptr @_Z27test_exception_handling_newv( +// CHECK: invoke noalias noundef nonnull ptr @_Znwm(i64 noundef 72) +// CHECK-NEXT: !alloc_token [[META_TESTCLASS:![0-9]+]] +TestClass *test_exception_handling_new() { + try { + TestClass *obj = new TestClass(); + may_throw(); + return obj; + } catch (...) { + return nullptr; + } +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z14test_new_classv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 72){{.*}} !alloc_token [[META_TESTCLASS]] +TestClass *test_new_class() { + TestClass *obj = new TestClass(); + obj->data[0] = 42; + return obj; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z20test_new_class_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 728){{.*}} !alloc_token [[META_TESTCLASS]] +TestClass *test_new_class_array() { + TestClass* arr = new TestClass[10]; + arr[0].data[0] = 123; + return arr; +} + +// CHECK: [[META_INT]] = !{!"int"} +// CHECK: [[META_TESTCLASS]] = !{!"TestClass"} diff --git a/clang/test/CodeGenCXX/builtin-invoke.cpp b/clang/test/CodeGenCXX/builtin-invoke.cpp index af66dfd4d..0f84f83 100644 --- a/clang/test/CodeGenCXX/builtin-invoke.cpp +++ b/clang/test/CodeGenCXX/builtin-invoke.cpp @@ -55,7 +55,7 @@ extern "C" void call_memptr(std::reference_wrapper<Callable> wrapper) { // CHECK-NEXT: br label %memptr.end // CHECK-EMPTY: // CHECK-NEXT: memptr.end: - // CHECK-NEXT: %2 = phi ptr [ %memptr.virtualfn, %memptr.virtual ], [ @_ZN8Callable4funcEv, %memptr.nonvirtual ] + // CHECK-NEXT: %2 = phi ptr [ %memptr.virtualfn, %memptr.virtual ], [ inttoptr (i64 ptrtoint (ptr @_ZN8Callable4funcEv to i64) to ptr), %memptr.nonvirtual ] // CHECK-NEXT: call void %2(ptr noundef nonnull align 1 dereferenceable(1) %0) // CHECK-NEXT: ret void } diff --git a/clang/test/Driver/aarch64-cpu-defaults-appleos26.c b/clang/test/Driver/aarch64-cpu-defaults-appleos26.c index 9917605..fe468a5 100644 --- a/clang/test/Driver/aarch64-cpu-defaults-appleos26.c +++ b/clang/test/Driver/aarch64-cpu-defaults-appleos26.c @@ -4,12 +4,16 @@ // RUN: %clang -target arm64-apple-ios26 -### -c %s 2>&1 | FileCheck %s --check-prefix=A12 // RUN: %clang -target arm64e-apple-ios26 -### -c %s 2>&1 | FileCheck %s --check-prefix=A12 +/// iOS 18 came before iOS 26, compare its defaults. +// RUN: %clang -target arm64-apple-ios18 -### -c %s 2>&1 | FileCheck %s --check-prefix=A10 +// RUN: %clang -target arm64e-apple-ios18 -### -c %s 2>&1 | FileCheck %s --check-prefix=A12 + /// arm64e/arm64_32 watchOS 26 default to apple-s6. // RUN: %clang -target arm64e-apple-watchos26 -### -c %s 2>&1 | FileCheck %s --check-prefix=S6 // RUN: %clang -target arm64_32-apple-watchos26 -### -c %s 2>&1 | FileCheck %s --check-prefix=S6 -/// arm64 is new in watchOS 26, and defaults to apple-s6. -// RUN: %clang -target arm64-apple-watchos26 -### -c %s 2>&1 | FileCheck %s --check-prefix=S6 +/// arm64 is new in watchOS 26, and defaults to apple-s9. +// RUN: %clang -target arm64-apple-watchos26 -### -c %s 2>&1 | FileCheck %s --check-prefix=S9 /// llvm usually treats tvOS like iOS, but it runs on different hardware. // RUN: %clang -target arm64-apple-tvos26 -### -c %s 2>&1 | FileCheck %s --check-prefix=A7 @@ -18,5 +22,7 @@ /// Simulators are tested with other Mac-like targets in aarch64-mac-cpus.c. // A12: "-target-cpu" "apple-a12" +// A10: "-target-cpu" "apple-a10" // S6: "-target-cpu" "apple-s6" +// S9: "-target-cpu" "apple-s9" // A7: "-target-cpu" "apple-a7" diff --git a/clang/test/Driver/amdgpu-openmp-sanitize-options.c b/clang/test/Driver/amdgpu-openmp-sanitize-options.c index 985eca1..914e018 100644 --- a/clang/test/Driver/amdgpu-openmp-sanitize-options.c +++ b/clang/test/Driver/amdgpu-openmp-sanitize-options.c @@ -59,6 +59,6 @@ // GPUSAN: {{"[^"]*clang[^"]*" "-cc1" "-triple" "amdgcn-amd-amdhsa" "-aux-triple" "x86_64-unknown-linux-gnu".* "-emit-llvm-bc".* "-mlink-bitcode-file" "[^"]*asanrtl.bc".* "-mlink-bitcode-file" "[^"]*ockl.bc".* "-target-cpu" "(gfx908|gfx900)".* "-fopenmp".* "-fsanitize=address".* "-x" "c".*}} // NOGPUSAN: {{"[^"]*clang[^"]*" "-cc1" "-triple" "amdgcn-amd-amdhsa" "-aux-triple" "x86_64-unknown-linux-gnu".* "-emit-llvm-bc".* "-target-cpu" "(gfx908|gfx900)".* "-fopenmp".* "-x" "c".*}} -// SAN: {{"[^"]*clang-offload-packager[^"]*" "-o".* "--image=file=.*.bc,triple=amdgcn-amd-amdhsa,arch=gfx908(:xnack\-|:xnack\+)?,kind=openmp(,feature=(\-xnack|\+xnack))?"}} +// SAN: {{"[^"]*llvm-offload-binary[^"]*" "-o".* "--image=file=.*.bc,triple=amdgcn-amd-amdhsa,arch=gfx908(:xnack\-|:xnack\+)?,kind=openmp(,feature=(\-xnack|\+xnack))?"}} // SAN: {{"[^"]*clang[^"]*" "-cc1" "-triple" "x86_64-unknown-linux-gnu".* "-fopenmp".* "-fsanitize=address".* "--offload-targets=amdgcn-amd-amdhsa".* "-x" "ir".*}} // SAN: {{"[^"]*clang-linker-wrapper[^"]*".* "--host-triple=x86_64-unknown-linux-gnu".* "--linker-path=[^"]*".* "--whole-archive" "[^"]*(libclang_rt.asan_static.a|libclang_rt.asan_static-x86_64.a)".* "--whole-archive" "[^"]*(libclang_rt.asan.a|libclang_rt.asan-x86_64.a)".*}} diff --git a/clang/test/Driver/amdgpu-openmp-toolchain.c b/clang/test/Driver/amdgpu-openmp-toolchain.c index 1091e6e..5e73e2d 100644 --- a/clang/test/Driver/amdgpu-openmp-toolchain.c +++ b/clang/test/Driver/amdgpu-openmp-toolchain.c @@ -22,7 +22,7 @@ // CHECK-PHASES: 6: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (amdgcn-amd-amdhsa:gfx906)" {5}, ir // CHECK-PHASES: 7: backend, {6}, ir, (device-openmp, gfx906) // CHECK-PHASES: 8: offload, "device-openmp (amdgcn-amd-amdhsa:gfx906)" {7}, ir -// CHECK-PHASES: 9: clang-offload-packager, {8}, image, (device-openmp) +// CHECK-PHASES: 9: llvm-offload-binary, {8}, image, (device-openmp) // CHECK-PHASES: 10: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (x86_64-unknown-linux-gnu)" {9}, ir // CHECK-PHASES: 11: backend, {10}, assembler, (host-openmp) // CHECK-PHASES: 12: assembler, {11}, object, (host-openmp) @@ -64,7 +64,7 @@ // RUN: %clang -### -target x86_64-pc-linux-gnu -fopenmp --offload-arch=gfx90a:sramecc-:xnack+ \ // RUN: -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-TARGET-ID // CHECK-TARGET-ID: "-cc1" "-triple" "amdgcn-amd-amdhsa" {{.*}} "-target-cpu" "gfx90a" "-target-feature" "-sramecc" "-target-feature" "+xnack" -// CHECK-TARGET-ID: clang-offload-packager{{.*}}arch=gfx90a:sramecc-:xnack+,kind=openmp +// CHECK-TARGET-ID: llvm-offload-binary{{.*}}arch=gfx90a:sramecc-:xnack+,kind=openmp // RUN: not %clang -### -target x86_64-pc-linux-gnu -fopenmp --offload-arch=gfx90a,gfx90a:xnack+ \ // RUN: -nogpulib %s 2>&1 | FileCheck %s --check-prefix=CHECK-TARGET-ID-ERROR diff --git a/clang/test/Driver/cuda-phases.cu b/clang/test/Driver/cuda-phases.cu index 220a320..db7d29e 100644 --- a/clang/test/Driver/cuda-phases.cu +++ b/clang/test/Driver/cuda-phases.cu @@ -235,7 +235,7 @@ // NEW-DRIVER-RDC-NEXT: 12: backend, {11}, assembler, (device-cuda, sm_70) // NEW-DRIVER-RDC-NEXT: 13: assembler, {12}, object, (device-cuda, sm_70) // NEW-DRIVER-RDC-NEXT: 14: offload, "device-cuda (nvptx64-nvidia-cuda:sm_70)" {13}, object -// NEW-DRIVER-RDC-NEXT: 15: clang-offload-packager, {8, 14}, image, (device-cuda) +// NEW-DRIVER-RDC-NEXT: 15: llvm-offload-binary, {8, 14}, image, (device-cuda) // NEW-DRIVER-RDC-NEXT: 16: offload, "host-cuda (powerpc64le-ibm-linux-gnu)" {2}, "device-cuda (powerpc64le-ibm-linux-gnu)" {15}, ir // NEW-DRIVER-RDC-NEXT: 17: backend, {16}, assembler, (host-cuda) // NEW-DRIVER-RDC-NEXT: 18: assembler, {17}, object, (host-cuda) @@ -312,7 +312,7 @@ // LTO-NEXT: 10: compiler, {9}, ir, (device-cuda, sm_70) // LTO-NEXT: 11: backend, {10}, lto-bc, (device-cuda, sm_70) // LTO-NEXT: 12: offload, "device-cuda (nvptx64-nvidia-cuda:sm_70)" {11}, lto-bc -// LTO-NEXT: 13: clang-offload-packager, {7, 12}, image, (device-cuda) +// LTO-NEXT: 13: llvm-offload-binary, {7, 12}, image, (device-cuda) // LTO-NEXT: 14: offload, "host-cuda (powerpc64le-ibm-linux-gnu)" {2}, "device-cuda (powerpc64le-ibm-linux-gnu)" {13}, ir // LTO-NEXT: 15: backend, {14}, assembler, (host-cuda) // LTO-NEXT: 16: assembler, {15}, object, (host-cuda) diff --git a/clang/test/Driver/darwin-maccatalyst-error.c b/clang/test/Driver/darwin-maccatalyst-error.c new file mode 100644 index 0000000..009249b --- /dev/null +++ b/clang/test/Driver/darwin-maccatalyst-error.c @@ -0,0 +1,6 @@ +// RUN: not %clang -target x86_64-apple-ios13.0-macabi -c %s -### 2>&1 | \ +// RUN: FileCheck --check-prefix=CHECK-ERROR %s +// RUN: not %clang -target x86_64-apple-ios12.0-macabi -c %s -### 2>&1 | \ +// RUN: FileCheck --check-prefix=CHECK-ERROR %s + +// CHECK-ERROR: error: invalid version number in '-target x86_64-apple-ios diff --git a/clang/test/Driver/darwin-maccatalyst.c b/clang/test/Driver/darwin-maccatalyst.c index 74a02ed..a8d53df 100644 --- a/clang/test/Driver/darwin-maccatalyst.c +++ b/clang/test/Driver/darwin-maccatalyst.c @@ -2,11 +2,6 @@ // RUN: FileCheck --check-prefix=CHECK-VERSION1 %s // RUN: %clang -target x86_64-apple-ios-macabi -c %s -### 2>&1 | \ // RUN: FileCheck --check-prefix=CHECK-VERSION1 %s -// RUN: not %clang -target x86_64-apple-ios13.0-macabi -c %s -### 2>&1 | \ -// RUN: FileCheck --check-prefix=CHECK-ERROR %s -// RUN: not %clang -target x86_64-apple-ios12.0-macabi -c %s -### 2>&1 | \ -// RUN: FileCheck --check-prefix=CHECK-ERROR %s // CHECK-VERSION1-NOT: error: // CHECK-VERSION1: "x86_64-apple-ios13.1.0-macabi" -// CHECK-ERROR: error: invalid version number in '-target x86_64-apple-ios diff --git a/clang/test/Driver/env.c b/clang/test/Driver/env.c index 56c037c..d1267c0 100644 --- a/clang/test/Driver/env.c +++ b/clang/test/Driver/env.c @@ -1,5 +1,7 @@ // Some assertions in this test use Linux style (/) file paths. -// UNSUPPORTED: system-windows +// TODO: Use LIBPATH on AIX +// UNSUPPORTED: system-windows, system-aix + // RUN: bash -c env | grep LD_LIBRARY_PATH | sed -ne 's/^.*=//p' | tr -d '\n' > %t.ld_library_path // The PATH variable is heavily used when trying to find a linker. // RUN: env -i LC_ALL=C LD_LIBRARY_PATH="%{readfile:%t.ld_library_path}" CLANG_NO_DEFAULT_CONFIG=1 \ diff --git a/clang/test/Driver/fsanitize-alloc-token.c b/clang/test/Driver/fsanitize-alloc-token.c new file mode 100644 index 0000000..2964f60 --- /dev/null +++ b/clang/test/Driver/fsanitize-alloc-token.c @@ -0,0 +1,43 @@ +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TOKEN-ALLOC +// CHECK-TOKEN-ALLOC: "-fsanitize=alloc-token" + +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fno-sanitize=alloc-token %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-TOKEN-ALLOC +// CHECK-NO-TOKEN-ALLOC-NOT: "-fsanitize=alloc-token" + +// RUN: %clang --target=x86_64-linux-gnu -flto -fvisibility=hidden -fno-sanitize-ignorelist -fsanitize=alloc-token,undefined,cfi %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-COMPATIBLE +// CHECK-COMPATIBLE: "-fsanitize={{.*}}alloc-token" + +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MINIMAL +// CHECK-MINIMAL: "-fsanitize=alloc-token" +// CHECK-MINIMAL: "-fsanitize-minimal-runtime" + +// RUN: %clang --target=arm-arm-non-eabi -fsanitize=alloc-token %s -### 2>&1 | FileCheck %s -check-prefix=CHECK-BAREMETAL +// RUN: %clang --target=aarch64-none-elf -fsanitize=alloc-token %s -### 2>&1 | FileCheck %s -check-prefix=CHECK-BAREMETAL +// CHECK-BAREMETAL: "-fsanitize=alloc-token" + +// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=alloc-token,address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INCOMPATIBLE-ADDRESS +// CHECK-INCOMPATIBLE-ADDRESS: error: invalid argument '-fsanitize=alloc-token' not allowed with '-fsanitize=address' + +// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=alloc-token,memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INCOMPATIBLE-MEMORY +// CHECK-INCOMPATIBLE-MEMORY: error: invalid argument '-fsanitize=alloc-token' not allowed with '-fsanitize=memory' + +// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-trap=alloc-token %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INCOMPATIBLE-TRAP +// CHECK-INCOMPATIBLE-TRAP: error: unsupported argument 'alloc-token' to option '-fsanitize-trap=' + +// RUN: not %clang --target=x86_64-linux-gnu %s -fsanitize=alloc-token -fsanitize-recover=alloc-token -### 2>&1 | FileCheck %s --check-prefix=CHECK-INCOMPATIBLE-RECOVER +// CHECK-INCOMPATIBLE-RECOVER: unsupported argument 'alloc-token' to option '-fsanitize-recover=' + +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-alloc-token-fast-abi %s -### 2>&1 | FileCheck -check-prefix=CHECK-FASTABI %s +// CHECK-FASTABI: "-fsanitize-alloc-token-fast-abi" +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-alloc-token-fast-abi -fno-sanitize-alloc-token-fast-abi %s -### 2>&1 | FileCheck -check-prefix=CHECK-NOFASTABI %s +// CHECK-NOFASTABI-NOT: "-fsanitize-alloc-token-fast-abi" + +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-alloc-token-extended %s -### 2>&1 | FileCheck -check-prefix=CHECK-EXTENDED %s +// CHECK-EXTENDED: "-fsanitize-alloc-token-extended" +// RUN: %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -fsanitize-alloc-token-extended -fno-sanitize-alloc-token-extended %s -### 2>&1 | FileCheck -check-prefix=CHECK-NOEXTENDED %s +// CHECK-NOEXTENDED-NOT: "-fsanitize-alloc-token-extended" + +// RUN: %clang --target=x86_64-linux-gnu -falloc-token-max=0 -falloc-token-max=42 %s -### 2>&1 | FileCheck -check-prefix=CHECK-MAX %s +// CHECK-MAX: "-falloc-token-max=42" +// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=alloc-token -falloc-token-max=-1 %s 2>&1 | FileCheck -check-prefix=CHECK-INVALID-MAX %s +// CHECK-INVALID-MAX: error: invalid value diff --git a/clang/test/Driver/fuse-ld.c b/clang/test/Driver/fuse-ld.c index f807434..cdcd512 100644 --- a/clang/test/Driver/fuse-ld.c +++ b/clang/test/Driver/fuse-ld.c @@ -101,3 +101,8 @@ // RUN: | FileCheck %s --check-prefix CHECK-WINDOWS-MSVC-BFD // CHECK-WINDOWS-MSVC-BFD: "{{.*}}ld.bfd" // CHECK-WINDOWS-MSVC-BFD-SAME: "-o" + +// RUN: %clang %s -### -fuse-ld=lld \ +// RUN: --target=x86_64-unknown-uefi 2>&1 \ +// RUN: | FileCheck %s --check-prefix CHECK-UEFI-LLD-LINK +// CHECK-UEFI-LLD-LINK: "{{.*}}lld-link diff --git a/clang/test/Driver/hip-phases.hip b/clang/test/Driver/hip-phases.hip index 6bac97a..13f682f 100644 --- a/clang/test/Driver/hip-phases.hip +++ b/clang/test/Driver/hip-phases.hip @@ -40,7 +40,7 @@ // OLD-DAG: [[P9:[0-9]+]]: offload, "device-[[T]] (amdgcn-amd-amdhsa:[[ARCH]])" {[[P8]]}, image // NEW-DAG: [[P9:[0-9]+]]: offload, "device-[[T]] (amdgcn-amd-amdhsa:[[ARCH]])" {[[P6]]}, ir // OLDN-DAG: [[P10:[0-9]+]]: linker, {[[P9]]}, hip-fatbin, (device-[[T]]) -// NEW-DAG: [[P10:[0-9]+]]: clang-offload-packager, {[[P9]]}, image, (device-[[T]]) +// NEW-DAG: [[P10:[0-9]+]]: llvm-offload-binary, {[[P9]]}, image, (device-[[T]]) // OLDR-DAG: [[P10:[0-9]+]]: linker, {[[P9]]}, object, (device-[[T]]) // OLDN-DAG: [[P11:[0-9]+]]: offload, "host-[[T]] (x86_64-unknown-linux-gnu)" {[[P2]]}, "device-[[T]] (amdgcn-amd-amdhsa)" {[[P10]]}, ir @@ -665,7 +665,7 @@ // LTO-NEXT: 10: compiler, {9}, ir, (device-hip, gfx90a) // LTO-NEXT: 11: backend, {10}, lto-bc, (device-hip, gfx90a) // LTO-NEXT: 12: offload, "device-hip (amdgcn-amd-amdhsa:gfx90a)" {11}, lto-bc -// LTO-NEXT: 13: clang-offload-packager, {7, 12}, image, (device-hip) +// LTO-NEXT: 13: llvm-offload-binary, {7, 12}, image, (device-hip) // LTO-NEXT: 14: offload, "host-hip (x86_64-unknown-linux-gnu)" {2}, "device-hip (x86_64-unknown-linux-gnu)" {13}, ir // LTO-NEXT: 15: backend, {14}, assembler, (host-hip) // LTO-NEXT: 16: assembler, {15}, object, (host-hip) diff --git a/clang/test/Driver/hip-toolchain-no-rdc.hip b/clang/test/Driver/hip-toolchain-no-rdc.hip index dc8f0a9..a94299e 100644 --- a/clang/test/Driver/hip-toolchain-no-rdc.hip +++ b/clang/test/Driver/hip-toolchain-no-rdc.hip @@ -97,7 +97,7 @@ // OLD-SAME: "-targets={{.*}},hipv4-amdgcn-amd-amdhsa--gfx803,hipv4-amdgcn-amd-amdhsa--gfx900" // OLD-SAME: "-input={{.*}}" "-input=[[IMG_DEV_A_803]]" "-input=[[IMG_DEV_A_900]]" "-output=[[BUNDLE_A:.*hipfb]]" -// NEW: [[PACKAGER:".*clang-offload-packager"]] "-o" "[[PACKAGE_A:.*.out]]" +// NEW: [[PACKAGER:".*llvm-offload-binary"]] "-o" "[[PACKAGE_A:.*.out]]" // NEW-SAME: "--image=file=[[OBJ_DEV_A_803]],triple=amdgcn-amd-amdhsa,arch=gfx803,kind=hip" // NEW-SAME: "--image=file=[[OBJ_DEV_A_900]],triple=amdgcn-amd-amdhsa,arch=gfx900,kind=hip" @@ -169,7 +169,7 @@ // OLD-SAME: "-targets={{.*}},hipv4-amdgcn-amd-amdhsa--gfx803,hipv4-amdgcn-amd-amdhsa--gfx900" // OLD-SAME: "-input={{.*}}" "-input=[[IMG_DEV_B_803]]" "-input=[[IMG_DEV_B_900]]" "-output=[[BUNDLE_B:.*hipfb]]" -// NEW: [[PACKAGER:".*clang-offload-packager"]] "-o" "[[PACKAGE_B:.*.out]]" +// NEW: [[PACKAGER:".*llvm-offload-binary"]] "-o" "[[PACKAGE_B:.*.out]]" // NEW-SAME: "--image=file=[[OBJ_DEV_B_803]],triple=amdgcn-amd-amdhsa,arch=gfx803,kind=hip" // NEW-SAME: "--image=file=[[OBJ_DEV_B_900]],triple=amdgcn-amd-amdhsa,arch=gfx900,kind=hip" diff --git a/clang/test/Driver/linker-wrapper-image.c b/clang/test/Driver/linker-wrapper-image.c index 3147617..b932712 100644 --- a/clang/test/Driver/linker-wrapper-image.c +++ b/clang/test/Driver/linker-wrapper-image.c @@ -5,7 +5,7 @@ // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.elf.o -// RUN: clang-offload-packager -o %t.out --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 +// RUN: llvm-offload-binary -o %t.out --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o \ // RUN: -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --print-wrapped-module --dry-run --host-triple=x86_64-unknown-linux-gnu \ @@ -42,7 +42,7 @@ // OPENMP-NEXT: ret void // OPENMP-NEXT: } -// RUN: clang-offload-packager -o %t.out --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_70 +// RUN: llvm-offload-binary -o %t.out --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o \ // RUN: -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --print-wrapped-module --dry-run --host-triple=x86_64-unknown-linux-gnu \ @@ -153,7 +153,7 @@ // CUDA-NEXT: ret void // CUDA-NEXT: } -// RUN: clang-offload-packager -o %t.out --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx908 +// RUN: llvm-offload-binary -o %t.out --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o \ // RUN: -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --print-wrapped-module --dry-run --host-triple=x86_64-unknown-linux-gnu \ @@ -265,7 +265,7 @@ // HIP-NEXT: ret void // HIP-NEXT: } -// RUN: clang-offload-packager -o %t.out --image=file=%t.elf.o,kind=sycl,triple=spirv64-unknown-unknown,arch=generic +// RUN: llvm-offload-binary -o %t.out --image=file=%t.elf.o,kind=sycl,triple=spirv64-unknown-unknown,arch=generic // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o \ // RUN: -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --print-wrapped-module --dry-run --host-triple=x86_64-unknown-linux-gnu \ diff --git a/clang/test/Driver/linker-wrapper.c b/clang/test/Driver/linker-wrapper.c index 1c0fb96..52a961d 100644 --- a/clang/test/Driver/linker-wrapper.c +++ b/clang/test/Driver/linker-wrapper.c @@ -12,7 +12,7 @@ __attribute__((visibility("protected"), used)) int x; // RUN: %clang -cc1 %s -triple amdgcn-amd-amdhsa -emit-llvm-bc -o %t.amdgpu.bc // RUN: %clang -cc1 %s -triple spirv64-unknown-unknown -emit-llvm-bc -o %t.spirv.bc -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -24,7 +24,7 @@ __attribute__((visibility("protected"), used)) int x; // NVPTX-LINK: clang{{.*}} -o {{.*}}.img -dumpdir a.out.nvptx64.sm_70.img. --target=nvptx64-nvidia-cuda -march=sm_70 {{.*}}.o {{.*}}.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -33,7 +33,7 @@ __attribute__((visibility("protected"), used)) int x; // NVPTX-LINK-DEBUG: clang{{.*}} --target=nvptx64-nvidia-cuda -march=sm_70 {{.*}}-g -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -42,7 +42,7 @@ __attribute__((visibility("protected"), used)) int x; // AMDGPU-LINK: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx908.img. --target=amdgcn-amd-amdhsa -mcpu=gfx908 -flto -Wl,--no-undefined {{.*}}.o {{.*}}.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.amdgpu.bc,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx1030 \ // RUN: --image=file=%t.amdgpu.bc,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx1030 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -51,7 +51,7 @@ __attribute__((visibility("protected"), used)) int x; // AMDGPU-LTO-TEMPS: clang{{.*}} --target=amdgcn-amd-amdhsa -mcpu=gfx1030 -flto {{.*}}-save-temps -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.spirv.bc,kind=sycl,triple=spirv64-unknown-unknown,arch=generic // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --dry-run \ @@ -59,7 +59,7 @@ __attribute__((visibility("protected"), used)) int x; // SPIRV-LINK: clang{{.*}} -o {{.*}}.img -dumpdir a.out.spirv64..img. --target=spirv64-unknown-unknown {{.*}}.o --sycl-link -Xlinker -triple=spirv64-unknown-unknown -Xlinker -arch= -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=x86_64-unknown-linux-gnu \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=x86_64-unknown-linux-gnu // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -77,12 +77,12 @@ __attribute__((visibility("protected"), used)) int x; // HOST-LINK: ld.lld{{.*}}-a -b -c {{.*}}.o -o a.out // HOST-LINK-NOT: ld.lld{{.*}}-abc -// RUN: clang-offload-packager -o %t-lib.out \ +// RUN: llvm-offload-binary -o %t-lib.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_52 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t-lib.out // RUN: llvm-ar rcs %t.a %t.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t-obj.o -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --dry-run \ @@ -91,7 +91,7 @@ __attribute__((visibility("protected"), used)) int x; // STATIC-LIBRARY: clang{{.*}} -march=sm_70 // STATIC-LIBRARY-NOT: clang{{.*}} -march=sm_50 -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_52 @@ -105,7 +105,7 @@ __attribute__((visibility("protected"), used)) int x; // CUDA: fatbinary{{.*}}-64 --create {{.*}}.fatbin --image=profile=sm_70,file=[[IMG_SM70]] --image=profile=sm_52,file=[[IMG_SM52]] // CUDA: usr/bin/ld{{.*}} {{.*}}.openmp.image.{{.*}}.o {{.*}}.cuda.image.{{.*}}.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_80 \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_75 \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_70 \ @@ -119,7 +119,7 @@ __attribute__((visibility("protected"), used)) int x; // CUDA-PAR: fatbinary{{.*}}-64 --create {{.*}}.fatbin -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx90a \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a \ // RUN: --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx908 @@ -133,7 +133,7 @@ __attribute__((visibility("protected"), used)) int x; // HIP: clang{{.*}} -o [[IMG_GFX908:.+]] -dumpdir a.out.amdgcn.gfx908.img. --target=amdgcn-amd-amdhsa -mcpu=gfx908 // HIP: clang-offload-bundler{{.*}}-type=o -bundle-align=4096 -compress -compression-level=6 -targets=host-x86_64-unknown-linux-gnu,hip-amdgcn-amd-amdhsa--gfx90a,hip-amdgcn-amd-amdhsa--gfx908 -input={{/dev/null|NUL}} -input=[[IMG_GFX90A]] -input=[[IMG_GFX908]] -output={{.*}}.hipfb -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o \ @@ -152,7 +152,7 @@ __attribute__((visibility("protected"), used)) int x; // MISSING-LIBRARY: error: unable to find library -ldummy -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.amdgpu.bc,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t.amdgpu.bc,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -161,7 +161,7 @@ __attribute__((visibility("protected"), used)) int x; // CLANG-BACKEND: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx908.img. --target=amdgcn-amd-amdhsa -mcpu=gfx908 -flto -Wl,--no-undefined {{.*}}.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-windows-msvc -emit-obj -o %t.o -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-windows-msvc --dry-run \ @@ -169,14 +169,14 @@ __attribute__((visibility("protected"), used)) int x; // COFF: "/usr/bin/lld-link" {{.*}}.o -libpath:./ -out:a.exe {{.*}}openmp.image.wrapper{{.*}} -// RUN: clang-offload-packager -o %t-lib.out \ +// RUN: llvm-offload-binary -o %t-lib.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t-lib.out // RUN: llvm-ar rcs %t.a %t.o -// RUN: clang-offload-packager -o %t-on.out \ +// RUN: llvm-offload-binary -o %t-on.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a:xnack+ // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t-on.o -fembed-offload-object=%t-on.out -// RUN: clang-offload-packager -o %t-off.out \ +// RUN: llvm-offload-binary -o %t-off.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a:xnack- // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t-off.o -fembed-offload-object=%t-off.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --dry-run \ @@ -185,14 +185,14 @@ __attribute__((visibility("protected"), used)) int x; // AMD-TARGET-ID: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx90a:xnack+.img. --target=amdgcn-amd-amdhsa -mcpu=gfx90a:xnack+ -flto -Wl,--no-undefined {{.*}}.o {{.*}}.o // AMD-TARGET-ID: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx90a:xnack-.img. --target=amdgcn-amd-amdhsa -mcpu=gfx90a:xnack- -flto -Wl,--no-undefined {{.*}}.o {{.*}}.o -// RUN: clang-offload-packager -o %t-lib.out \ +// RUN: llvm-offload-binary -o %t-lib.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=generic // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t-lib.out // RUN: llvm-ar rcs %t.a %t.o -// RUN: clang-offload-packager -o %t1.out \ +// RUN: llvm-offload-binary -o %t1.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t1.o -fembed-offload-object=%t1.out -// RUN: clang-offload-packager -o %t2.out \ +// RUN: llvm-offload-binary -o %t2.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t2.o -fembed-offload-object=%t2.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --dry-run \ @@ -201,7 +201,7 @@ __attribute__((visibility("protected"), used)) int x; // ARCH-ALL: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx90a.img. --target=amdgcn-amd-amdhsa -mcpu=gfx90a -flto -Wl,--no-undefined {{.*}}.o {{.*}}.o // ARCH-ALL: clang{{.*}} -o {{.*}}.img -dumpdir a.out.amdgcn.gfx908.img. --target=amdgcn-amd-amdhsa -mcpu=gfx908 -flto -Wl,--no-undefined {{.*}}.o {{.*}}.o -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=x86_64-unknown-linux-gnu \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=x86_64-unknown-linux-gnu // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -213,7 +213,7 @@ __attribute__((visibility("protected"), used)) int x; // RELOCATABLE-LINK: /usr/bin/ld.lld{{.*}}-r // RELOCATABLE-LINK: llvm-objcopy{{.*}}a.out --remove-section .llvm.offloading -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx90a \ // RUN: --image=file=%t.elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx90a // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -227,7 +227,7 @@ __attribute__((visibility("protected"), used)) int x; // RELOCATABLE-LINK-HIP: llvm-objcopy{{.*}}a.out --remove-section .llvm.offloading // RELOCATABLE-LINK-HIP: --rename-section llvm_offload_entries -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_89 \ // RUN: --image=file=%t.elf.o,kind=cuda,triple=nvptx64-nvidia-cuda,arch=sm_89 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out @@ -247,7 +247,7 @@ __attribute__((visibility("protected"), used)) int x; // OVERRIDE-NOT: clang // OVERRIDE: /usr/bin/ld -// RUN: clang-offload-packager -o %t.out \ +// RUN: llvm-offload-binary -o %t.out \ // RUN: --image=file=%t.elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t.o -fembed-offload-object=%t.out // RUN: clang-linker-wrapper --host-triple=x86_64-unknown-linux-gnu --dry-run \ diff --git a/clang/test/Driver/offload-packager.c b/clang/test/Driver/offload-packager.c index fb5f100..adf2565 100644 --- a/clang/test/Driver/offload-packager.c +++ b/clang/test/Driver/offload-packager.c @@ -7,26 +7,26 @@ // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t/elf.o // Check that we can extract files from the packaged binary. -// RUN: clang-offload-packager -o %t/package.out \ +// RUN: llvm-offload-binary -o %t/package.out \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_80 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90c -// RUN: clang-offload-packager %t/package.out \ +// RUN: llvm-offload-binary %t/package.out \ // RUN: --image=file=%t/sm_70.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t/gfx908.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: diff %t/sm_70.o %t/elf.o // RUN: diff %t/gfx908.o %t/elf.o // Check that we generate a new name if one is not given -// RUN: clang-offload-packager -o %t/package \ +// RUN: llvm-offload-binary -o %t/package \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_80 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx90a \ // RUN: --image=file=%t/elf.o,kind=hip,triple=amdgcn-amd-amdhsa,arch=gfx90c -// RUN: clang-offload-packager %t/package --image=kind=openmp +// RUN: llvm-offload-binary %t/package --image=kind=openmp // RUN: diff *-nvptx64-nvidia-cuda-sm_70.0.o %t/elf.o; rm *-nvptx64-nvidia-cuda-sm_70.0.o // RUN: diff *-nvptx64-nvidia-cuda-sm_80.1.o %t/elf.o; rm *-nvptx64-nvidia-cuda-sm_80.1.o // RUN: diff *-amdgcn-amd-amdhsa-gfx908.2.o %t/elf.o; rm *-amdgcn-amd-amdhsa-gfx908.2.o @@ -34,33 +34,33 @@ // RUN: not diff *-amdgcn-amd-amdhsa-gfx90c.4.o %t/elf.o // Check that we can extract from an ELF object file -// RUN: clang-offload-packager -o %t/package.out \ +// RUN: llvm-offload-binary -o %t/package.out \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t/package.o -fembed-offload-object=%t/package.out -// RUN: clang-offload-packager %t/package.out \ +// RUN: llvm-offload-binary %t/package.out \ // RUN: --image=file=%t/sm_70.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t/gfx908.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: diff %t/sm_70.o %t/elf.o // RUN: diff %t/gfx908.o %t/elf.o // Check that we can extract from a bitcode file -// RUN: clang-offload-packager -o %t/package.out \ +// RUN: llvm-offload-binary -o %t/package.out \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-llvm -o %t/package.bc -fembed-offload-object=%t/package.out -// RUN: clang-offload-packager %t/package.out \ +// RUN: llvm-offload-binary %t/package.out \ // RUN: --image=file=%t/sm_70.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 \ // RUN: --image=file=%t/gfx908.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 // RUN: diff %t/sm_70.o %t/elf.o // RUN: diff %t/gfx908.o %t/elf.o // Check that we can extract from an archive file to an archive file. -// RUN: clang-offload-packager -o %t/package.out \ +// RUN: llvm-offload-binary -o %t/package.out \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=amdgcn-amd-amdhsa,arch=gfx908 \ // RUN: --image=file=%t/elf.o,kind=openmp,triple=nvptx64-nvidia-cuda,arch=sm_70 // RUN: %clang -cc1 %s -triple x86_64-unknown-linux-gnu -emit-obj -o %t/package.o -fembed-offload-object=%t/package.out // RUN: llvm-ar rcs %t/package.a %t/package.o -// RUN: clang-offload-packager %t/package.a --archive --image=file=%t/gfx908.a,arch=gfx908 +// RUN: llvm-offload-binary %t/package.a --archive --image=file=%t/gfx908.a,arch=gfx908 // RUN: llvm-ar t %t/gfx908.a 2>&1 | FileCheck %s // CHECK: {{.*}}.o diff --git a/clang/test/Driver/openmp-offload-gpu.c b/clang/test/Driver/openmp-offload-gpu.c index 77f4cfb..edce14e 100644 --- a/clang/test/Driver/openmp-offload-gpu.c +++ b/clang/test/Driver/openmp-offload-gpu.c @@ -242,7 +242,7 @@ // CHECK-PHASES: 7: backend, {6}, assembler, (device-openmp, sm_52) // CHECK-PHASES: 8: assembler, {7}, object, (device-openmp, sm_52) // CHECK-PHASES: 9: offload, "device-openmp (nvptx64-nvidia-cuda:sm_52)" {8}, object -// CHECK-PHASES: 10: clang-offload-packager, {9}, image +// CHECK-PHASES: 10: llvm-offload-binary, {9}, image // CHECK-PHASES: 11: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (x86_64-unknown-linux-gnu)" {10}, ir // CHECK-PHASES: 12: backend, {11}, assembler, (host-openmp) // CHECK-PHASES: 13: assembler, {12}, object, (host-openmp) @@ -346,13 +346,13 @@ // RUN: %clang -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=sm_52 -nogpulib \ // RUN: -foffload-lto %s 2>&1 | FileCheck --check-prefix=CHECK-LTO-FEATURES %s -// CHECK-LTO-FEATURES: clang-offload-packager{{.*}}--image={{.*}}feature=+ptx{{[0-9]+}} +// CHECK-LTO-FEATURES: llvm-offload-binary{{.*}}--image={{.*}}feature=+ptx{{[0-9]+}} // RUN: %clang -### --target=x86_64-unknown-linux-gnu -fopenmp=libomp --offload-arch=sm_52 -nogpulib \ // RUN: -Xopenmp-target=nvptx64-nvidia-cuda --cuda-feature=+ptx64 -foffload-lto %s 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-SET-FEATURES %s -// CHECK-SET-FEATURES: clang-offload-packager{{.*}}--image={{.*}}feature=+ptx64 +// CHECK-SET-FEATURES: llvm-offload-binary{{.*}}--image={{.*}}feature=+ptx64 // // Check that `-Xarch_host` works for OpenMP offloading. diff --git a/clang/test/Driver/openmp-offload-jit.c b/clang/test/Driver/openmp-offload-jit.c index b3566f0..6ced5c1 100644 --- a/clang/test/Driver/openmp-offload-jit.c +++ b/clang/test/Driver/openmp-offload-jit.c @@ -25,7 +25,7 @@ // PHASES-JIT-NEXT: 6: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp ([[TARGET:.+]])" {5}, ir // PHASES-JIT-NEXT: 7: backend, {6}, lto-bc, (device-openmp, {{.*}}) // PHASES-JIT-NEXT: 8: offload, "device-openmp ([[TARGET]])" {7}, lto-bc -// PHASES-JIT-NEXT: 9: clang-offload-packager, {8}, image, (device-openmp) +// PHASES-JIT-NEXT: 9: llvm-offload-binary, {8}, image, (device-openmp) // PHASES-JIT-NEXT: 10: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (x86_64-unknown-linux-gnu)" {9}, ir // PHASES-JIT-NEXT: 11: backend, {10}, assembler, (host-openmp) // PHASES-JIT-NEXT: 12: assembler, {11}, object, (host-openmp) diff --git a/clang/test/Driver/openmp-offload.c b/clang/test/Driver/openmp-offload.c index 64d45f9..fce1b88 100644 --- a/clang/test/Driver/openmp-offload.c +++ b/clang/test/Driver/openmp-offload.c @@ -103,7 +103,7 @@ // CHK-PHASES-NEXT: 7: backend, {6}, assembler, (device-openmp) // CHK-PHASES-NEXT: 8: assembler, {7}, object, (device-openmp) // CHK-PHASES-NEXT: 9: offload, "device-openmp (powerpc64-ibm-linux-gnu)" {8}, object -// CHK-PHASES-NEXT: 10: clang-offload-packager, {9}, image, (device-openmp) +// CHK-PHASES-NEXT: 10: llvm-offload-binary, {9}, image, (device-openmp) // CHK-PHASES-NEXT: 11: offload, "host-openmp (powerpc64-ibm-linux-gnu)" {2}, "device-openmp (powerpc64-ibm-linux-gnu)" {10}, ir // CHK-PHASES-NEXT: 12: backend, {11}, assembler, (host-openmp) // CHK-PHASES-NEXT: 13: assembler, {12}, object, (host-openmp) @@ -132,7 +132,7 @@ // CHK-PHASES-FILES-NEXT: 15: backend, {14}, assembler, (device-openmp) // CHK-PHASES-FILES-NEXT: 16: assembler, {15}, object, (device-openmp) // CHK-PHASES-FILES-NEXT: 17: offload, "device-openmp (x86_64-pc-linux-gnu)" {16}, object -// CHK-PHASES-FILES-NEXT: 18: clang-offload-packager, {10, 17}, image, (device-openmp) +// CHK-PHASES-FILES-NEXT: 18: llvm-offload-binary, {10, 17}, image, (device-openmp) // CHK-PHASES-FILES-NEXT: 19: offload, "host-openmp (powerpc64-ibm-linux-gnu)" {3}, "device-openmp (powerpc64-ibm-linux-gnu)" {18}, ir // CHK-PHASES-FILES-NEXT: 20: backend, {19}, assembler, (host-openmp) // CHK-PHASES-FILES-NEXT: 21: assembler, {20}, object, (host-openmp) @@ -153,7 +153,7 @@ // CHK-PHASES-FILES-NEXT: 36: backend, {35}, assembler, (device-openmp) // CHK-PHASES-FILES-NEXT: 37: assembler, {36}, object, (device-openmp) // CHK-PHASES-FILES-NEXT: 38: offload, "device-openmp (x86_64-pc-linux-gnu)" {37}, object -// CHK-PHASES-FILES-NEXT: 39: clang-offload-packager, {31, 38}, image, (device-openmp) +// CHK-PHASES-FILES-NEXT: 39: llvm-offload-binary, {31, 38}, image, (device-openmp) // CHK-PHASES-FILES-NEXT: 40: offload, "host-openmp (powerpc64-ibm-linux-gnu)" {24}, "device-openmp (powerpc64-ibm-linux-gnu)" {39}, ir // CHK-PHASES-FILES-NEXT: 41: backend, {40}, assembler, (host-openmp) // CHK-PHASES-FILES-NEXT: 42: assembler, {41}, object, (host-openmp) diff --git a/clang/test/Driver/print-supported-extensions-riscv.c b/clang/test/Driver/print-supported-extensions-riscv.c index c44a0e8..7972b9e 100644 --- a/clang/test/Driver/print-supported-extensions-riscv.c +++ b/clang/test/Driver/print-supported-extensions-riscv.c @@ -216,7 +216,7 @@ // CHECK-NEXT: zibi 0.1 'Zibi' (Branch with Immediate) // CHECK-NEXT: zicfilp 1.0 'Zicfilp' (Landing pad) // CHECK-NEXT: zicfiss 1.0 'Zicfiss' (Shadow stack) -// CHECK-NEXT: zalasr 0.1 'Zalasr' (Load-Acquire and Store-Release Instructions) +// CHECK-NEXT: zalasr 0.9 'Zalasr' (Load-Acquire and Store-Release Instructions) // CHECK-NEXT: zvbc32e 0.7 'Zvbc32e' (Vector Carryless Multiplication with 32-bits elements) // CHECK-NEXT: zvfbfa 0.1 'Zvfbfa' (Additional BF16 vector compute support) // CHECK-NEXT: zvfofp8min 0.2 'Zvfofp8min' (Vector OFP8 Converts) diff --git a/clang/test/Driver/riscv-arch.c b/clang/test/Driver/riscv-arch.c index 1da8311..37fe7a0 100644 --- a/clang/test/Driver/riscv-arch.c +++ b/clang/test/Driver/riscv-arch.c @@ -384,9 +384,9 @@ // RUN: not %clang --target=riscv32-unknown-elf -march=rv32izalasr0p7 -menable-experimental-extensions -### %s \ // RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-EXPERIMENTAL-BADVERS %s // RV32-EXPERIMENTAL-BADVERS: error: invalid arch name 'rv32izalasr0p7' -// RV32-EXPERIMENTAL-BADVERS: unsupported version number 0.7 for experimental extension 'zalasr' (this compiler supports 0.1) +// RV32-EXPERIMENTAL-BADVERS: unsupported version number 0.7 for experimental extension 'zalasr' (this compiler supports 0.9) -// RUN: %clang --target=riscv32-unknown-elf -march=rv32izalasr0p1 -menable-experimental-extensions -### %s \ +// RUN: %clang --target=riscv32-unknown-elf -march=rv32izalasr0p9 -menable-experimental-extensions -### %s \ // RUN: -fsyntax-only 2>&1 | FileCheck -check-prefix=RV32-EXPERIMENTAL-GOODVERS %s // RV32-EXPERIMENTAL-GOODVERS: "-target-feature" "+experimental-zalasr" diff --git a/clang/test/Driver/spirv-openmp-toolchain.c b/clang/test/Driver/spirv-openmp-toolchain.c index 1542f50..6bf8984 100644 --- a/clang/test/Driver/spirv-openmp-toolchain.c +++ b/clang/test/Driver/spirv-openmp-toolchain.c @@ -21,7 +21,7 @@ // CHECK-PHASES: 7: backend, {6}, assembler, (device-openmp) // CHECK-PHASES: 8: assembler, {7}, object, (device-openmp) // CHECK-PHASES: 9: offload, "device-openmp (spirv64-intel)" {8}, object -// CHECK-PHASES: 10: clang-offload-packager, {9}, image, (device-openmp) +// CHECK-PHASES: 10: llvm-offload-binary, {9}, image, (device-openmp) // CHECK-PHASES: 11: offload, "host-openmp (x86_64-unknown-linux-gnu)" {2}, "device-openmp (x86_64-unknown-linux-gnu)" {10}, ir // CHECK-PHASES: 12: backend, {11}, assembler, (host-openmp) // CHECK-PHASES: 13: assembler, {12}, object, (host-openmp) diff --git a/clang/test/Driver/sycl-offload-jit.cpp b/clang/test/Driver/sycl-offload-jit.cpp index e040f4d..72c2390 100644 --- a/clang/test/Driver/sycl-offload-jit.cpp +++ b/clang/test/Driver/sycl-offload-jit.cpp @@ -13,21 +13,21 @@ // CHK-PHASES-NEXT: 5: compiler, {4}, ir, (device-sycl) // CHK-PHASES-NEXT: 6: backend, {5}, ir, (device-sycl) // CHK-PHASES-NEXT: 7: offload, "device-sycl (spirv64-unknown-unknown)" {6}, ir -// CHK-PHASES-NEXT: 8: clang-offload-packager, {7}, image, (device-sycl) +// CHK-PHASES-NEXT: 8: llvm-offload-binary, {7}, image, (device-sycl) // CHK-PHASES-NEXT: 9: offload, "host-sycl (x86_64{{.*}})" {2}, "device-sycl (x86_64{{.*}})" {8}, ir // CHK-PHASES-NEXT: 10: backend, {9}, assembler, (host-sycl) // CHK-PHASES-NEXT: 11: assembler, {10}, object, (host-sycl) // CHK-PHASES-NEXT: 12: clang-linker-wrapper, {11}, image, (host-sycl) /// Check expected default values for device compilation when using -fsycl as -/// well as clang-offload-packager inputs. +/// well as llvm-offload-binary inputs. // RUN: %clang -### -fsycl -c --target=x86_64-unknown-linux-gnu %s 2>&1 \ // RUN: | FileCheck -check-prefix=CHK-DEVICE-TRIPLE %s // CHK-DEVICE-TRIPLE: "-cc1"{{.*}} "-triple" "spirv64-unknown-unknown" // CHK-DEVICE-TRIPLE-SAME: "-aux-triple" "x86_64-unknown-linux-gnu" // CHK-DEVICE-TRIPLE-SAME: "-fsycl-is-device" // CHK-DEVICE-TRIPLE-SAME: "-O2" -// CHK-DEVICE-TRIPLE: clang-offload-packager{{.*}} "--image=file={{.*}}.bc,triple=spirv64-unknown-unknown,arch=generic,kind=sycl" +// CHK-DEVICE-TRIPLE: llvm-offload-binary{{.*}} "--image=file={{.*}}.bc,triple=spirv64-unknown-unknown,arch=generic,kind=sycl" /// Check -fsycl-is-device is passed when compiling for the device. /// Check -fsycl-is-host is passed when compiling for host. diff --git a/clang/test/Driver/uefi-constructed-args.c b/clang/test/Driver/uefi-constructed-args.c index c06cce3..b06920f 100644 --- a/clang/test/Driver/uefi-constructed-args.c +++ b/clang/test/Driver/uefi-constructed-args.c @@ -12,3 +12,8 @@ // CHECK-SAME: "/entry:EfiMain" // CHECK-SAME: "/tsaware:no" // CHECK-SAME: "/debug" + +// RUN: %clang -### --target=x86_64-unknown-uefi -print-search-dirs 2>&1 \ +// RUN: | FileCheck -check-prefixes=PROGPATH %s +// PROGPATH: InstalledDir: [[DRIVER_INSTALLED_DIR:.*]] +// PROGPATH: programs: =[[DRIVER_INSTALLED_DIR]] diff --git a/clang/test/Preprocessor/alloc_token.cpp b/clang/test/Preprocessor/alloc_token.cpp new file mode 100644 index 0000000..0c51bfb --- /dev/null +++ b/clang/test/Preprocessor/alloc_token.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -E -fsanitize=alloc-token %s -o - | FileCheck --check-prefix=CHECK-SANITIZE %s +// RUN: %clang_cc1 -E %s -o - | FileCheck --check-prefix=CHECK-DEFAULT %s + +#if __SANITIZE_ALLOC_TOKEN__ +// CHECK-SANITIZE: has_sanitize_alloc_token +int has_sanitize_alloc_token(); +#else +// CHECK-DEFAULT: no_sanitize_alloc_token +int no_sanitize_alloc_token(); +#endif diff --git a/clang/test/Preprocessor/print-header-json.c b/clang/test/Preprocessor/print-header-json.c index 057dcc2..e0533cd 100644 --- a/clang/test/Preprocessor/print-header-json.c +++ b/clang/test/Preprocessor/print-header-json.c @@ -22,6 +22,7 @@ #include "system2.h" // RUN: rm %t.txt +// RUN: rm -rf %t // RUN: env CC_PRINT_HEADERS_FORMAT=json CC_PRINT_HEADERS_FILTERING=direct-per-file CC_PRINT_HEADERS_FILE=%t.txt %clang -fsyntax-only -I %S/Inputs/print-header-json -isystem %S/Inputs/print-header-json/system -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -o /dev/null // RUN: cat %t.txt | FileCheck %s --check-prefix=SUPPORTED_PERFILE_MODULES diff --git a/clang/test/Preprocessor/riscv-target-features.c b/clang/test/Preprocessor/riscv-target-features.c index 71d8453..77731a9 100644 --- a/clang/test/Preprocessor/riscv-target-features.c +++ b/clang/test/Preprocessor/riscv-target-features.c @@ -1531,12 +1531,12 @@ // Experimental extensions // RUN: %clang --target=riscv32 -menable-experimental-extensions \ -// RUN: -march=rv32i_zalasr0p1 -E -dM %s \ +// RUN: -march=rv32i_zalasr0p9 -E -dM %s \ // RUN: -o - | FileCheck --check-prefix=CHECK-ZALASR-EXT %s // RUN: %clang --target=riscv64 -menable-experimental-extensions \ -// RUN: -march=rv64i_zalasr0p1 -E -dM %s \ +// RUN: -march=rv64i_zalasr0p9 -E -dM %s \ // RUN: -o - | FileCheck --check-prefix=CHECK-ZALASR-EXT %s -// CHECK-ZALASR-EXT: __riscv_zalasr 1000{{$}} +// CHECK-ZALASR-EXT: __riscv_zalasr 9000{{$}} // RUN: %clang --target=riscv32 -menable-experimental-extensions \ // RUN: -march=rv32izfbfmin1p0 -E -dM %s \ diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme.c b/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme.c new file mode 100644 index 0000000..f695e27 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme.c @@ -0,0 +1,48 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme" flags="streaming-compatible,requires-za" + +void test(void) __arm_inout("za"){ + int64_t int64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + svldr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svldr_za(uint32_t_val, void_ptr_val); + svstr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svstr_za(uint32_t_val, void_ptr_val); + svzero_mask_za(2); + svzero_za(); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + int64_t int64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + svldr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svldr_za(uint32_t_val, void_ptr_val); + svstr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svstr_za(uint32_t_val, void_ptr_val); + svzero_mask_za(2); + svzero_za(); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + int64_t int64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + svldr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svldr_za(uint32_t_val, void_ptr_val); + svstr_vnum_za(uint32_t_val, void_ptr_val, int64_t_val); + svstr_za(uint32_t_val, void_ptr_val); + svzero_mask_za(2); + svzero_za(); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme_AND_sme2.c b/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme_AND_sme2.c new file mode 100644 index 0000000..ea17ab9 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_compatible_sme_AND_sme2.c @@ -0,0 +1,33 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2" flags="streaming-compatible,requires-zt" + +void test(void) __arm_inout("zt0"){ + void * void_ptr_val; + + svldr_zt(0, void_ptr_val); + svstr_zt(0, void_ptr_val); + svzero_zt(0); +} + +void test_streaming(void) __arm_streaming __arm_inout("zt0"){ + void * void_ptr_val; + + svldr_zt(0, void_ptr_val); + svstr_zt(0, void_ptr_val); + svzero_zt(0); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("zt0"){ + void * void_ptr_val; + + svldr_zt(0, void_ptr_val); + svstr_zt(0, void_ptr_val); + svzero_zt(0); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme.c new file mode 100644 index 0000000..29bc3aa --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme.c @@ -0,0 +1,1491 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + svaddha_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + svaddha_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + svaddva_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + svaddva_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + svld1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svld1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + svld1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + svmopa_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmopa_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmopa_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + svmopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + svmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + svmops_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmops_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmops_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmops_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + svmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + svmops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + svmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + svread_hor_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_hor_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_hor_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_hor_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + svread_ver_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + svread_ver_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + svread_ver_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + svst1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + svst1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + svst1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + svsumopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + svsumopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + svsumops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + svsumops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + svusmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + svusmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + svusmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + svusmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_hor_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_hor_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_hor_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_hor_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_hor_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_hor_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_hor_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_hor_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_hor_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_hor_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_hor_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_hor_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_hor_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_hor_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_hor_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_hor_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_hor_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_hor_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_hor_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_hor_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_hor_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_hor_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_hor_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_hor_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_hor_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_hor_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_ver_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_ver_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_ver_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_ver_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_ver_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_ver_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_ver_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_ver_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_ver_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_ver_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_ver_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_ver_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_ver_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_ver_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_ver_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_ver_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_ver_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + svwrite_ver_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + svwrite_ver_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + svwrite_ver_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + svwrite_ver_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + svwrite_ver_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + svwrite_ver_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + svwrite_ver_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + svwrite_ver_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + svwrite_ver_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + void * void_ptr_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_s32_m(2, svbool_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za32_u32_m(2, svbool_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_bf16_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_f16_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_f32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_hor_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_mf8_m(svmfloat8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_s8_m(svint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za8_u8_m(svuint8_t_val, svbool_t_val, 0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_bf16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_f16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svbfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svfloat16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_s16_m(svint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za16_u16_m(svuint16_t_val, svbool_t_val, 1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za32_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za64_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_bf16_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f16_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f32_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_f64_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svbfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svfloat64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_mf8_m(svmfloat8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s8_m(svint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s16_m(svint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s32_m(svint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_s64_m(svint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u8_m(svuint8_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u16_m(svuint16_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u32_m(svuint32_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svread_ver_za128_u64_m(svuint64_t_val, svbool_t_val, 2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_hor_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za8(0, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za16(1, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za32(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za64(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_vnum_za128(2, uint32_t_val, svbool_t_val, void_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za8(0, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za16(1, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za32(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za64(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_ver_za128(2, uint32_t_val, svbool_t_val, void_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za32_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za32_s8_m(2, svbool_t_val, svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za32_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za32_u8_m(2, svbool_t_val, svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_hor_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_mf8_m(0, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_s8_m(0, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za8_u8_m(0, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_bf16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_f16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_s16_m(1, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za16_u16_m(1, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za32_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za64_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_bf16_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f16_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f32_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_f64_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_mf8_m(2, uint32_t_val, svbool_t_val, svmfloat8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s8_m(2, uint32_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s16_m(2, uint32_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s32_m(2, uint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_s64_m(2, uint32_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u8_m(2, uint32_t_val, svbool_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u16_m(2, uint32_t_val, svbool_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u32_m(2, uint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_ver_za128_u64_m(2, uint32_t_val, svbool_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_LP_sme-f16f16_OR_sme-f8f16_RP.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_LP_sme-f16f16_OR_sme-f8f16_RP.c new file mode 100644 index 0000000..1216759 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_LP_sme-f16f16_OR_sme-f8f16_RP.c @@ -0,0 +1,70 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f16f16 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f16 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,(sme-f16f16|sme-f8f16)" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + svadd_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + svadd_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + svadd_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + svadd_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); + svsub_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + svsub_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + svsub_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + svsub_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x2(uint32_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x4(uint32_t_val, svfloat16x4_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-b16b16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-b16b16.c new file mode 100644 index 0000000..e5bfd67 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-b16b16.c @@ -0,0 +1,215 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-b16b16 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-b16b16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + uint32_t uint32_t_val; + + svadd_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + svadd_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + svadd_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + svadd_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + svmla_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + svmla_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + svmla_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + svmla_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + svmla_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + svmla_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + svmla_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmla_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svmls_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + svmls_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + svmls_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + svmls_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + svmls_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + svmls_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + svmls_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmls_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svmopa_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmops_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmops_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + svsub_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + svsub_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + svsub_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_bf16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_m(1, svbool_t_val, svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_bf16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_bf16_vg1x4(uint32_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x2(uint32_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za16_vg1x4(uint32_t_val, svbfloat16x4_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f16f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f16f16.c new file mode 100644 index 0000000..8189d71 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f16f16.c @@ -0,0 +1,175 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f16f16 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-f16f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + svmla_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + svmla_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + svmla_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + svmla_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + svmla_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + svmla_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + svmla_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svmla_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svmls_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + svmls_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + svmls_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + svmls_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + svmls_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + svmls_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + svmls_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svmls_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svmopa_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmops_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmops_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_f16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_f16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x2(uint32_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za16_vg1x4(uint32_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_f16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za16_m(1, svbool_t_val, svbool_t_val, svfloat16_t_val, svfloat16_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f64f64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f64f64.c new file mode 100644 index 0000000..7d47a07 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f64f64.c @@ -0,0 +1,46 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f64f64 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-f64f64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat64_t svfloat64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat64_t svfloat64_t_val; + + svmopa_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmops_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmops_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbool_t svbool_t_val; + svfloat64_t svfloat64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_f64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f16.c new file mode 100644 index 0000000..32e1f82 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f16.c @@ -0,0 +1,198 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f16 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-f8f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_mf8_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + svdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_single_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svdot_single_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svdot_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmla_lane_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_single_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmla_single_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmla_single_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmla_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmla_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmopa_za16_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmopa_za16_mf8_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svvdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svvdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za16_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_mf8_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_mf8_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za16_vg2x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za16_mf8_m_fpm(1, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za16_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za16_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f32.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f32.c new file mode 100644 index 0000000..11c7f38 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-f8f32.c @@ -0,0 +1,208 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f32 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-f8f32" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_mf8_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdotb_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdotb_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdott_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdott_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + svdot_lane_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svdot_single_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svdot_single_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svdot_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmla_lane_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_lane_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + svmla_single_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmla_single_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmla_single_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmla_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmla_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + svmopa_za32_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmopa_za32_mf8_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svvdotb_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svvdotb_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svvdott_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + svvdott_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svbool_t svbool_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_mf8_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za32_vg1x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_mf8_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_mf8_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x1_fpm(uint32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x2_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za32_vg4x4_fpm(uint32_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za32_mf8_m_fpm(2, svbool_t_val, svbool_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdotb_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdotb_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdott_lane_za32_mf8_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdott_lane_za32_vg1x4_fpm(uint32_t_val, svmfloat8x2_t_val, svmfloat8_t_val, 2, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-i16i64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-i16i64.c new file mode 100644 index 0000000..cae434b --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-i16i64.c @@ -0,0 +1,155 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-i16i64 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-i16i64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbool_t svbool_t_val; + svint16_t svint16_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint64_t svuint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbool_t svbool_t_val; + svint16_t svint16_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint64_t svuint64_t_val; + + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + svaddha_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + svaddha_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + svaddva_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + svaddva_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + svmopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + svmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + svmops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + svmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + svmops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + svmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + svsumopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + svsumopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + svsumops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + svsumops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + svusmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + svusmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + svusmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + svusmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbool_t svbool_t_val; + svint16_t svint16_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint64_t svuint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddha_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_s64_m(2, svbool_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddva_za64_u64_m(2, svbool_t_val, svbool_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumopa_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za64_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsumops_za64_s16_m(2, svbool_t_val, svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmopa_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za64_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svusmops_za64_u16_m(2, svbool_t_val, svbool_t_val, svuint16_t_val, svint16_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-lutv2.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-lutv2.c new file mode 100644 index 0000000..5f90d3f --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme-lutv2.c @@ -0,0 +1,309 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-lutv2 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme-lutv2" flags="streaming-only,requires-zt" + +void test(void) __arm_inout("zt0"){ + svbfloat16_t svbfloat16_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_zt_s8_x4(0, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_zt_u8_x4(0, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_bf16(0, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f16(0, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f32(0, svfloat32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f64(0, svfloat64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s8(0, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s16(0, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s32(0, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s64(0, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u16(0, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u32(0, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u64(0, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_bf16(0, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f16(0, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f32(0, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f64(0, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s8(0, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s16(0, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s32(0, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s64(0, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u8(0, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u16(0, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u32(0, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u64(0, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("zt0"){ + svbfloat16_t svbfloat16_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + svluti4_zt_s8_x4(0, svuint8x2_t_val); + svluti4_zt_u8_x4(0, svuint8x2_t_val); + svwrite_lane_zt(0, svbfloat16_t_val, 2); + svwrite_lane_zt(0, svfloat16_t_val, 2); + svwrite_lane_zt(0, svfloat32_t_val, 2); + svwrite_lane_zt(0, svfloat64_t_val, 2); + svwrite_lane_zt(0, svint8_t_val, 2); + svwrite_lane_zt(0, svint16_t_val, 2); + svwrite_lane_zt(0, svint32_t_val, 2); + svwrite_lane_zt(0, svint64_t_val, 2); + svwrite_lane_zt(0, svuint8_t_val, 2); + svwrite_lane_zt(0, svuint16_t_val, 2); + svwrite_lane_zt(0, svuint32_t_val, 2); + svwrite_lane_zt(0, svuint64_t_val, 2); + svwrite_lane_zt_bf16(0, svbfloat16_t_val, 2); + svwrite_lane_zt_f16(0, svfloat16_t_val, 2); + svwrite_lane_zt_f32(0, svfloat32_t_val, 2); + svwrite_lane_zt_f64(0, svfloat64_t_val, 2); + svwrite_lane_zt_s8(0, svint8_t_val, 2); + svwrite_lane_zt_s16(0, svint16_t_val, 2); + svwrite_lane_zt_s32(0, svint32_t_val, 2); + svwrite_lane_zt_s64(0, svint64_t_val, 2); + svwrite_lane_zt_u8(0, svuint8_t_val, 2); + svwrite_lane_zt_u16(0, svuint16_t_val, 2); + svwrite_lane_zt_u32(0, svuint32_t_val, 2); + svwrite_lane_zt_u64(0, svuint64_t_val, 2); + svwrite_zt(0, svbfloat16_t_val); + svwrite_zt(0, svfloat16_t_val); + svwrite_zt(0, svfloat32_t_val); + svwrite_zt(0, svfloat64_t_val); + svwrite_zt(0, svint8_t_val); + svwrite_zt(0, svint16_t_val); + svwrite_zt(0, svint32_t_val); + svwrite_zt(0, svint64_t_val); + svwrite_zt(0, svuint8_t_val); + svwrite_zt(0, svuint16_t_val); + svwrite_zt(0, svuint32_t_val); + svwrite_zt(0, svuint64_t_val); + svwrite_zt_bf16(0, svbfloat16_t_val); + svwrite_zt_f16(0, svfloat16_t_val); + svwrite_zt_f32(0, svfloat32_t_val); + svwrite_zt_f64(0, svfloat64_t_val); + svwrite_zt_s8(0, svint8_t_val); + svwrite_zt_s16(0, svint16_t_val); + svwrite_zt_s32(0, svint32_t_val); + svwrite_zt_s64(0, svint64_t_val); + svwrite_zt_u8(0, svuint8_t_val); + svwrite_zt_u16(0, svuint16_t_val); + svwrite_zt_u32(0, svuint32_t_val); + svwrite_zt_u64(0, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("zt0"){ + svbfloat16_t svbfloat16_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_zt_s8_x4(0, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_zt_u8_x4(0, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svfloat64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt(0, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_bf16(0, svbfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f16(0, svfloat16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f32(0, svfloat32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_f64(0, svfloat64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s8(0, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s16(0, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s32(0, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_s64(0, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u16(0, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u32(0, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_lane_zt_u64(0, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt(0, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_bf16(0, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f16(0, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f32(0, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_f64(0, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s8(0, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s16(0, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s32(0, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_s64(0, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u8(0, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u16(0, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u32(0, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwrite_zt_u64(0, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2.c new file mode 100644 index 0000000..1e52425 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2.c @@ -0,0 +1,308 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2" flags="streaming-only,requires-zt" + +void test(void) __arm_inout("zt0"){ + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_mf8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_mf8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32_x4(0, svuint8_t_val, 1); +} + +void test_streaming(void) __arm_streaming __arm_inout("zt0"){ + svuint8_t svuint8_t_val; + + svluti2_lane_zt_bf16(0, svuint8_t_val, 2); + svluti2_lane_zt_bf16_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_bf16_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_f16(0, svuint8_t_val, 2); + svluti2_lane_zt_f16_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_f16_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_f32(0, svuint8_t_val, 2); + svluti2_lane_zt_f32_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_f32_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_mf8(0, svuint8_t_val, 2); + svluti2_lane_zt_mf8_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_mf8_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_s8(0, svuint8_t_val, 2); + svluti2_lane_zt_s8_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_s8_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_s16(0, svuint8_t_val, 2); + svluti2_lane_zt_s16_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_s16_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_s32(0, svuint8_t_val, 2); + svluti2_lane_zt_s32_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_s32_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_u8(0, svuint8_t_val, 2); + svluti2_lane_zt_u8_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_u8_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_u16(0, svuint8_t_val, 2); + svluti2_lane_zt_u16_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_u16_x4(0, svuint8_t_val, 2); + svluti2_lane_zt_u32(0, svuint8_t_val, 2); + svluti2_lane_zt_u32_x2(0, svuint8_t_val, 2); + svluti2_lane_zt_u32_x4(0, svuint8_t_val, 2); + svluti4_lane_zt_bf16(0, svuint8_t_val, 2); + svluti4_lane_zt_bf16_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_bf16_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_f16(0, svuint8_t_val, 2); + svluti4_lane_zt_f16_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_f16_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_f32(0, svuint8_t_val, 2); + svluti4_lane_zt_f32_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_f32_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_mf8(0, svuint8_t_val, 2); + svluti4_lane_zt_mf8_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_s8(0, svuint8_t_val, 2); + svluti4_lane_zt_s8_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_s16(0, svuint8_t_val, 2); + svluti4_lane_zt_s16_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_s16_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_s32(0, svuint8_t_val, 2); + svluti4_lane_zt_s32_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_s32_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_u8(0, svuint8_t_val, 2); + svluti4_lane_zt_u8_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_u16(0, svuint8_t_val, 2); + svluti4_lane_zt_u16_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_u16_x4(0, svuint8_t_val, 1); + svluti4_lane_zt_u32(0, svuint8_t_val, 2); + svluti4_lane_zt_u32_x2(0, svuint8_t_val, 2); + svluti4_lane_zt_u32_x4(0, svuint8_t_val, 1); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("zt0"){ + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_bf16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_f32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_mf8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_s32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u8_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u16_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_zt_u32_x4(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_bf16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_f32_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_mf8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_mf8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_s32_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u8(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u8_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u16_x4(0, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32_x2(0, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_zt_u32_x4(0, svuint8_t_val, 1); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-f64f64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-f64f64.c new file mode 100644 index 0000000..2766e7a --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-f64f64.c @@ -0,0 +1,192 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f64f64 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-f64f64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + uint32_t uint32_t_val; + + svadd_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + svadd_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + svadd_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + svadd_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); + svmla_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + svmla_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + svmla_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + svmla_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + svmla_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + svmla_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + svmla_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svmla_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svmls_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + svmls_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + svmls_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + svmls_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + svmls_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + svmls_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + svmls_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svmls_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svsub_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + svsub_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + svsub_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + svsub_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x2(uint32_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg1x4(uint32_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_f64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_f64_vg1x4(uint32_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svfloat64x4_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-i16i64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-i16i64.c new file mode 100644 index 0000000..36e7333 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-i16i64.c @@ -0,0 +1,759 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-i16i64 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-i16i64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint32_t uint32_t_val; + + svadd_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + svadd_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + svadd_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + svadd_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + svadd_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + svadd_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + svadd_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + svadd_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + svadd_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + svadd_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + svadd_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + svadd_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + svadd_za64_vg1x2(uint32_t_val, svint64x2_t_val); + svadd_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + svadd_za64_vg1x4(uint32_t_val, svint64x4_t_val); + svadd_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + svdot_lane_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + svdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + svdot_lane_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + svdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + svdot_lane_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + svdot_lane_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + svdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + svdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + svdot_single_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svdot_single_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svdot_single_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svdot_single_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svdot_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svdot_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svdot_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svdot_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svmla_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + svmla_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + svmla_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + svmla_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svmla_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + svmla_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + svmla_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + svmla_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svmla_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + svmla_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + svmla_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + svmla_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + svmla_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svmla_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svmla_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svmla_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svmla_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + svmla_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svmla_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svmla_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + svmla_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svmla_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svmla_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + svmla_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svmls_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + svmls_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + svmls_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + svmls_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svmls_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + svmls_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + svmls_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + svmls_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svmls_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + svmls_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + svmls_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + svmls_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + svmls_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svmls_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svmls_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svmls_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svmls_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + svmls_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svmls_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svmls_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + svmls_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svmls_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svmls_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + svmls_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + svsub_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + svsub_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + svsub_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + svsub_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + svsub_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + svsub_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + svsub_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + svsub_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + svsub_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + svsub_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + svsub_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + svsub_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + svsub_za64_vg1x2(uint32_t_val, svint64x2_t_val); + svsub_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + svsub_za64_vg1x4(uint32_t_val, svint64x4_t_val); + svsub_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + svvdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + svvdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + svvdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + svvdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_single_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_s16_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_u16_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_single_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_s16_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_u16_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x1(uint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x1(uint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x2(uint32_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_za64_vg4x4(uint32_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_single_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x2(uint32_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_write_za64_vg1x4(uint32_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_s64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_s64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_u64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_u64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x2(uint32_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsub_za64_vg1x4(uint32_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_s16_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_u16_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_vg1x4(uint32_t_val, svint16x4_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svvdot_lane_za64_vg1x4(uint32_t_val, svuint16x4_t_val, svuint16_t_val, 1); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4.c new file mode 100644 index 0000000..6e6e9d8 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4.c @@ -0,0 +1,782 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16x2_t_val, svuint16x2_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + svmop4a_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + svmop4a_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + svmop4a_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + svmop4a_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + svmop4a_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + svmop4a_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + svmop4a_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + svmop4a_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + svmop4a_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + svmop4a_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4a_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + svmop4a_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + svmop4a_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + svmop4a_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + svmop4a_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + svmop4a_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + svmop4a_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + svmop4a_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + svmop4a_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4a_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + svmop4a_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + svmop4a_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + svmop4a_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + svmop4a_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + svmop4a_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + svmop4a_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + svmop4a_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + svmop4a_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4a_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4a_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + svmop4a_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + svmop4a_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + svmop4a_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + svmop4a_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + svmop4a_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + svmop4a_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4a_za32(2, svbfloat16_t_val, svbfloat16_t_val); + svmop4a_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4a_za32(2, svfloat16_t_val, svfloat16_t_val); + svmop4a_za32(2, svfloat16_t_val, svfloat16x2_t_val); + svmop4a_za32(2, svfloat16x2_t_val, svfloat16_t_val); + svmop4a_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4a_za32(2, svfloat32_t_val, svfloat32_t_val); + svmop4a_za32(2, svfloat32_t_val, svfloat32x2_t_val); + svmop4a_za32(2, svfloat32x2_t_val, svfloat32_t_val); + svmop4a_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + svmop4a_za32(2, svint8_t_val, svint8_t_val); + svmop4a_za32(2, svint8_t_val, svint8x2_t_val); + svmop4a_za32(2, svint8_t_val, svuint8_t_val); + svmop4a_za32(2, svint8_t_val, svuint8x2_t_val); + svmop4a_za32(2, svint8x2_t_val, svint8_t_val); + svmop4a_za32(2, svint8x2_t_val, svint8x2_t_val); + svmop4a_za32(2, svint8x2_t_val, svuint8_t_val); + svmop4a_za32(2, svint8x2_t_val, svuint8x2_t_val); + svmop4a_za32(2, svint16_t_val, svint16_t_val); + svmop4a_za32(2, svint16_t_val, svint16x2_t_val); + svmop4a_za32(2, svint16x2_t_val, svint16_t_val); + svmop4a_za32(2, svint16x2_t_val, svint16x2_t_val); + svmop4a_za32(2, svuint8_t_val, svint8_t_val); + svmop4a_za32(2, svuint8_t_val, svint8x2_t_val); + svmop4a_za32(2, svuint8_t_val, svuint8_t_val); + svmop4a_za32(2, svuint8_t_val, svuint8x2_t_val); + svmop4a_za32(2, svuint8x2_t_val, svint8_t_val); + svmop4a_za32(2, svuint8x2_t_val, svint8x2_t_val); + svmop4a_za32(2, svuint8x2_t_val, svuint8_t_val); + svmop4a_za32(2, svuint8x2_t_val, svuint8x2_t_val); + svmop4a_za32(2, svuint16_t_val, svuint16_t_val); + svmop4a_za32(2, svuint16_t_val, svuint16x2_t_val); + svmop4a_za32(2, svuint16x2_t_val, svuint16_t_val); + svmop4a_za32(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4s_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + svmop4s_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + svmop4s_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + svmop4s_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + svmop4s_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + svmop4s_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + svmop4s_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + svmop4s_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + svmop4s_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + svmop4s_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4s_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + svmop4s_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + svmop4s_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + svmop4s_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + svmop4s_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + svmop4s_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + svmop4s_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + svmop4s_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + svmop4s_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4s_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + svmop4s_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + svmop4s_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + svmop4s_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + svmop4s_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + svmop4s_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + svmop4s_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + svmop4s_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + svmop4s_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4s_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4s_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + svmop4s_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + svmop4s_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + svmop4s_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + svmop4s_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + svmop4s_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + svmop4s_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4s_za32(2, svbfloat16_t_val, svbfloat16_t_val); + svmop4s_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4s_za32(2, svfloat16_t_val, svfloat16_t_val); + svmop4s_za32(2, svfloat16_t_val, svfloat16x2_t_val); + svmop4s_za32(2, svfloat16x2_t_val, svfloat16_t_val); + svmop4s_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4s_za32(2, svfloat32_t_val, svfloat32_t_val); + svmop4s_za32(2, svfloat32_t_val, svfloat32x2_t_val); + svmop4s_za32(2, svfloat32x2_t_val, svfloat32_t_val); + svmop4s_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + svmop4s_za32(2, svint8_t_val, svint8_t_val); + svmop4s_za32(2, svint8_t_val, svint8x2_t_val); + svmop4s_za32(2, svint8_t_val, svuint8_t_val); + svmop4s_za32(2, svint8_t_val, svuint8x2_t_val); + svmop4s_za32(2, svint8x2_t_val, svint8_t_val); + svmop4s_za32(2, svint8x2_t_val, svint8x2_t_val); + svmop4s_za32(2, svint8x2_t_val, svuint8_t_val); + svmop4s_za32(2, svint8x2_t_val, svuint8x2_t_val); + svmop4s_za32(2, svint16_t_val, svint16_t_val); + svmop4s_za32(2, svint16_t_val, svint16x2_t_val); + svmop4s_za32(2, svint16x2_t_val, svint16_t_val); + svmop4s_za32(2, svint16x2_t_val, svint16x2_t_val); + svmop4s_za32(2, svuint8_t_val, svint8_t_val); + svmop4s_za32(2, svuint8_t_val, svint8x2_t_val); + svmop4s_za32(2, svuint8_t_val, svuint8_t_val); + svmop4s_za32(2, svuint8_t_val, svuint8x2_t_val); + svmop4s_za32(2, svuint8x2_t_val, svint8_t_val); + svmop4s_za32(2, svuint8x2_t_val, svint8x2_t_val); + svmop4s_za32(2, svuint8x2_t_val, svuint8_t_val); + svmop4s_za32(2, svuint8x2_t_val, svuint8x2_t_val); + svmop4s_za32(2, svuint16_t_val, svuint16_t_val); + svmop4s_za32(2, svuint16_t_val, svuint16x2_t_val); + svmop4s_za32(2, svuint16x2_t_val, svuint16_t_val); + svmop4s_za32(2, svuint16x2_t_val, svuint16x2_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_f16_f16(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_f32_f32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s8_s8(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s8_u8(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u8_s8(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u8_u8(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za32_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_bf16_bf16(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_f16_f16(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_f32_f32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s8_s8(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s8_u8(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u8_s8(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u8_u8(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za32_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s8_s8(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_f16_f16(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_f32_f32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s8_s8(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s8_u8(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u8_s8(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u8_u8(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za32_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za32(2, svuint16x2_t_val, svuint16x2_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-b16b16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-b16b16.c new file mode 100644 index 0000000..cce8af0 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-b16b16.c @@ -0,0 +1,106 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-b16b16 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-b16b16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + + svmop4a_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + svmop4a_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4a_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4a_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4a_za16(1, svbfloat16_t_val, svbfloat16_t_val); + svmop4a_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4s_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + svmop4s_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4s_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4s_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + svmop4s_za16(1, svbfloat16_t_val, svbfloat16_t_val); + svmop4s_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za16_bf16_bf16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svbfloat16x2_t_val, svbfloat16x2_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f16f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f16f16.c new file mode 100644 index 0000000..5c6d223 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f16f16.c @@ -0,0 +1,106 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f16f16 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-f16f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + + svmop4a_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + svmop4a_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + svmop4a_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + svmop4a_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4a_za16(1, svfloat16_t_val, svfloat16_t_val); + svmop4a_za16(1, svfloat16_t_val, svfloat16x2_t_val); + svmop4a_za16(1, svfloat16x2_t_val, svfloat16_t_val); + svmop4a_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4s_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + svmop4s_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + svmop4s_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + svmop4s_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + svmop4s_za16(1, svfloat16_t_val, svfloat16_t_val); + svmop4s_za16(1, svfloat16_t_val, svfloat16x2_t_val); + svmop4s_za16(1, svfloat16x2_t_val, svfloat16_t_val); + svmop4s_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za16_f16_f16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za16_f16_f16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za16_f16_f16(1, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za16(1, svfloat16x2_t_val, svfloat16x2_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f64f64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f64f64.c new file mode 100644 index 0000000..14c8286 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f64f64.c @@ -0,0 +1,106 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f64f64 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-f64f64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + + svmop4a_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + svmop4a_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + svmop4a_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + svmop4a_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + svmop4a_za64(2, svfloat64_t_val, svfloat64_t_val); + svmop4a_za64(2, svfloat64_t_val, svfloat64x2_t_val); + svmop4a_za64(2, svfloat64x2_t_val, svfloat64_t_val); + svmop4a_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); + svmop4s_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + svmop4s_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + svmop4s_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + svmop4s_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + svmop4s_za64(2, svfloat64_t_val, svfloat64_t_val); + svmop4s_za64(2, svfloat64_t_val, svfloat64x2_t_val); + svmop4s_za64(2, svfloat64x2_t_val, svfloat64_t_val); + svmop4s_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_f64_f64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_f64_f64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_f64_f64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_f64_f64(2, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svfloat64x2_t_val, svfloat64x2_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f16.c new file mode 100644 index 0000000..a51b386 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f16.c @@ -0,0 +1,69 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f16 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-f8f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + svmop4a_1x1_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_1x2_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_2x1_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_2x2_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za16_mf8_mf8_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za16_fpm(1, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f32.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f32.c new file mode 100644 index 0000000..ba0fdab --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-f8f32.c @@ -0,0 +1,69 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f32 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-f8f32" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + svmop4a_1x1_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_1x2_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_2x1_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_2x2_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za32_mf8_mf8_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8_t_val, svmfloat8x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za32_fpm(2, svmfloat8x2_t_val, svmfloat8x2_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-i16i64.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-i16i64.c new file mode 100644 index 0000000..70137fd --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-mop4_AND_sme-i16i64.c @@ -0,0 +1,352 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-i16i64 -target-feature +sme-mop4 -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-mop4,sme-i16i64" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svuint16x2_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + svmop4a_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + svmop4a_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + svmop4a_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + svmop4a_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + svmop4a_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + svmop4a_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + svmop4a_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + svmop4a_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + svmop4a_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + svmop4a_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + svmop4a_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + svmop4a_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + svmop4a_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + svmop4a_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + svmop4a_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + svmop4a_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4a_za64(2, svint16_t_val, svint16_t_val); + svmop4a_za64(2, svint16_t_val, svint16x2_t_val); + svmop4a_za64(2, svint16_t_val, svuint16_t_val); + svmop4a_za64(2, svint16_t_val, svuint16x2_t_val); + svmop4a_za64(2, svint16x2_t_val, svint16_t_val); + svmop4a_za64(2, svint16x2_t_val, svint16x2_t_val); + svmop4a_za64(2, svint16x2_t_val, svuint16_t_val); + svmop4a_za64(2, svint16x2_t_val, svuint16x2_t_val); + svmop4a_za64(2, svuint16_t_val, svint16_t_val); + svmop4a_za64(2, svuint16_t_val, svint16x2_t_val); + svmop4a_za64(2, svuint16_t_val, svuint16_t_val); + svmop4a_za64(2, svuint16_t_val, svuint16x2_t_val); + svmop4a_za64(2, svuint16x2_t_val, svint16_t_val); + svmop4a_za64(2, svuint16x2_t_val, svint16x2_t_val); + svmop4a_za64(2, svuint16x2_t_val, svuint16_t_val); + svmop4a_za64(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4s_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + svmop4s_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + svmop4s_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + svmop4s_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + svmop4s_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + svmop4s_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + svmop4s_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + svmop4s_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + svmop4s_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + svmop4s_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + svmop4s_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + svmop4s_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + svmop4s_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + svmop4s_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + svmop4s_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + svmop4s_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + svmop4s_za64(2, svint16_t_val, svint16_t_val); + svmop4s_za64(2, svint16_t_val, svint16x2_t_val); + svmop4s_za64(2, svint16_t_val, svuint16_t_val); + svmop4s_za64(2, svint16_t_val, svuint16x2_t_val); + svmop4s_za64(2, svint16x2_t_val, svint16_t_val); + svmop4s_za64(2, svint16x2_t_val, svint16x2_t_val); + svmop4s_za64(2, svint16x2_t_val, svuint16_t_val); + svmop4s_za64(2, svint16x2_t_val, svuint16x2_t_val); + svmop4s_za64(2, svuint16_t_val, svint16_t_val); + svmop4s_za64(2, svuint16_t_val, svint16x2_t_val); + svmop4s_za64(2, svuint16_t_val, svuint16_t_val); + svmop4s_za64(2, svuint16_t_val, svuint16x2_t_val); + svmop4s_za64(2, svuint16x2_t_val, svint16_t_val); + svmop4s_za64(2, svuint16x2_t_val, svint16x2_t_val); + svmop4s_za64(2, svuint16x2_t_val, svuint16_t_val); + svmop4s_za64(2, svuint16x2_t_val, svuint16x2_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4a_za64(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_s16_s16(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_s16_u16(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_u16_s16(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x1_za64_u16_u16(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_s16_s16(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_s16_u16(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_u16_s16(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_1x2_za64_u16_u16(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_s16_s16(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_s16_u16(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_u16_s16(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x1_za64_u16_u16(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_s16_s16(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_s16_u16(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_u16_s16(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_2x2_za64_u16_u16(2, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmop4s_za64(2, svuint16x2_t_val, svuint16x2_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop.c new file mode 100644 index 0000000..aea2870 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop.c @@ -0,0 +1,152 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-tmop -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-tmop" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s8_s8(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s16_s16(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + svtmopa_lane_za32(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_s8_s8(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_s16_s16(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + svtmopa_lane_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_bf16_bf16(2, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_f16_f16(2, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_f32_f32(2, svfloat32x2_t_val, svfloat32_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s8_s8(2, svint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s8_u8(2, svint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_s16_s16(2, svint16x2_t_val, svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u8_s8(2, svuint8x2_t_val, svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u8_u8(2, svuint8x2_t_val, svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_u16_u16(2, svuint16x2_t_val, svuint16_t_val, svuint8_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-b16b16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-b16b16.c new file mode 100644 index 0000000..d53d9ec --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-b16b16.c @@ -0,0 +1,39 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-b16b16 -target-feature +sme-tmop -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-tmop,sme-b16b16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svuint8_t svuint8_t_val; + + svtmopa_lane_za16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_bf16_bf16(1, svbfloat16x2_t_val, svbfloat16_t_val, svuint8_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f16f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f16f16.c new file mode 100644 index 0000000..04591b6 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f16f16.c @@ -0,0 +1,39 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f16f16 -target-feature +sme-tmop -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-tmop,sme-f16f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svuint8_t svuint8_t_val; + + svtmopa_lane_za16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + svtmopa_lane_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_f16_f16(1, svfloat16x2_t_val, svfloat16_t_val, svuint8_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f16.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f16.c new file mode 100644 index 0000000..4a4d50a --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f16.c @@ -0,0 +1,42 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f16 -target-feature +sme-tmop -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-tmop,sme-f8f16" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + svtmopa_lane_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + svtmopa_lane_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za16_mf8_mf8_fpm(1, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f32.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f32.c new file mode 100644 index 0000000..4838a6f --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2_AND_sme-tmop_AND_sme-f8f32.c @@ -0,0 +1,42 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f8f32 -target-feature +sme-tmop -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2,sme-tmop,sme-f8f32" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + svtmopa_lane_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + svtmopa_lane_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + fpm_t fpm_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svuint8_t svuint8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtmopa_lane_za32_mf8_mf8_fpm(2, svmfloat8x2_t_val, svmfloat8_t_val, svuint8_t_val, 2, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2p1.c b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2p1.c new file mode 100644 index 0000000..661435e --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sme_streaming_only_sme_AND_sme2p1.c @@ -0,0 +1,713 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2p1 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sme.h> + +// Properties: guard="" streaming_guard="sme,sme2p1" flags="streaming-only,requires-za" + +void test(void) __arm_inout("za"){ + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_bf16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_mf8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_bf16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_mf8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_mf8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_mf8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_s8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_s8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_u8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_u8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_bf16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_bf16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_f16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_f16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_s16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_s16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_u16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_u16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_f32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_f32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_s32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_s32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_u32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_u32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_f64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_f64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_s64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_s64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_u64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_u64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x1(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x1(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x4(uint32_t_val); +} + +void test_streaming(void) __arm_streaming __arm_inout("za"){ + uint32_t uint32_t_val; + + svreadz_hor_za8_mf8(0, uint32_t_val); + svreadz_hor_za8_mf8_vg2(0, uint32_t_val); + svreadz_hor_za8_mf8_vg4(0, uint32_t_val); + svreadz_hor_za8_s8(0, uint32_t_val); + svreadz_hor_za8_s8_vg2(0, uint32_t_val); + svreadz_hor_za8_s8_vg4(0, uint32_t_val); + svreadz_hor_za8_u8(0, uint32_t_val); + svreadz_hor_za8_u8_vg2(0, uint32_t_val); + svreadz_hor_za8_u8_vg4(0, uint32_t_val); + svreadz_hor_za16_bf16(1, uint32_t_val); + svreadz_hor_za16_bf16_vg2(1, uint32_t_val); + svreadz_hor_za16_bf16_vg4(1, uint32_t_val); + svreadz_hor_za16_f16(1, uint32_t_val); + svreadz_hor_za16_f16_vg2(1, uint32_t_val); + svreadz_hor_za16_f16_vg4(1, uint32_t_val); + svreadz_hor_za16_s16(1, uint32_t_val); + svreadz_hor_za16_s16_vg2(1, uint32_t_val); + svreadz_hor_za16_s16_vg4(1, uint32_t_val); + svreadz_hor_za16_u16(1, uint32_t_val); + svreadz_hor_za16_u16_vg2(1, uint32_t_val); + svreadz_hor_za16_u16_vg4(1, uint32_t_val); + svreadz_hor_za32_f32(2, uint32_t_val); + svreadz_hor_za32_f32_vg2(2, uint32_t_val); + svreadz_hor_za32_f32_vg4(2, uint32_t_val); + svreadz_hor_za32_s32(2, uint32_t_val); + svreadz_hor_za32_s32_vg2(2, uint32_t_val); + svreadz_hor_za32_s32_vg4(2, uint32_t_val); + svreadz_hor_za32_u32(2, uint32_t_val); + svreadz_hor_za32_u32_vg2(2, uint32_t_val); + svreadz_hor_za32_u32_vg4(2, uint32_t_val); + svreadz_hor_za64_f64(2, uint32_t_val); + svreadz_hor_za64_f64_vg2(2, uint32_t_val); + svreadz_hor_za64_f64_vg4(2, uint32_t_val); + svreadz_hor_za64_s64(2, uint32_t_val); + svreadz_hor_za64_s64_vg2(2, uint32_t_val); + svreadz_hor_za64_s64_vg4(2, uint32_t_val); + svreadz_hor_za64_u64(2, uint32_t_val); + svreadz_hor_za64_u64_vg2(2, uint32_t_val); + svreadz_hor_za64_u64_vg4(2, uint32_t_val); + svreadz_hor_za128_bf16(2, uint32_t_val); + svreadz_hor_za128_f16(2, uint32_t_val); + svreadz_hor_za128_f32(2, uint32_t_val); + svreadz_hor_za128_f64(2, uint32_t_val); + svreadz_hor_za128_mf8(2, uint32_t_val); + svreadz_hor_za128_s8(2, uint32_t_val); + svreadz_hor_za128_s16(2, uint32_t_val); + svreadz_hor_za128_s32(2, uint32_t_val); + svreadz_hor_za128_s64(2, uint32_t_val); + svreadz_hor_za128_u8(2, uint32_t_val); + svreadz_hor_za128_u16(2, uint32_t_val); + svreadz_hor_za128_u32(2, uint32_t_val); + svreadz_hor_za128_u64(2, uint32_t_val); + svreadz_ver_za8_mf8(0, uint32_t_val); + svreadz_ver_za8_mf8_vg2(0, uint32_t_val); + svreadz_ver_za8_mf8_vg4(0, uint32_t_val); + svreadz_ver_za8_s8(0, uint32_t_val); + svreadz_ver_za8_s8_vg2(0, uint32_t_val); + svreadz_ver_za8_s8_vg4(0, uint32_t_val); + svreadz_ver_za8_u8(0, uint32_t_val); + svreadz_ver_za8_u8_vg2(0, uint32_t_val); + svreadz_ver_za8_u8_vg4(0, uint32_t_val); + svreadz_ver_za16_bf16(1, uint32_t_val); + svreadz_ver_za16_bf16_vg2(1, uint32_t_val); + svreadz_ver_za16_bf16_vg4(1, uint32_t_val); + svreadz_ver_za16_f16(1, uint32_t_val); + svreadz_ver_za16_f16_vg2(1, uint32_t_val); + svreadz_ver_za16_f16_vg4(1, uint32_t_val); + svreadz_ver_za16_s16(1, uint32_t_val); + svreadz_ver_za16_s16_vg2(1, uint32_t_val); + svreadz_ver_za16_s16_vg4(1, uint32_t_val); + svreadz_ver_za16_u16(1, uint32_t_val); + svreadz_ver_za16_u16_vg2(1, uint32_t_val); + svreadz_ver_za16_u16_vg4(1, uint32_t_val); + svreadz_ver_za32_f32(2, uint32_t_val); + svreadz_ver_za32_f32_vg2(2, uint32_t_val); + svreadz_ver_za32_f32_vg4(2, uint32_t_val); + svreadz_ver_za32_s32(2, uint32_t_val); + svreadz_ver_za32_s32_vg2(2, uint32_t_val); + svreadz_ver_za32_s32_vg4(2, uint32_t_val); + svreadz_ver_za32_u32(2, uint32_t_val); + svreadz_ver_za32_u32_vg2(2, uint32_t_val); + svreadz_ver_za32_u32_vg4(2, uint32_t_val); + svreadz_ver_za64_f64(2, uint32_t_val); + svreadz_ver_za64_f64_vg2(2, uint32_t_val); + svreadz_ver_za64_f64_vg4(2, uint32_t_val); + svreadz_ver_za64_s64(2, uint32_t_val); + svreadz_ver_za64_s64_vg2(2, uint32_t_val); + svreadz_ver_za64_s64_vg4(2, uint32_t_val); + svreadz_ver_za64_u64(2, uint32_t_val); + svreadz_ver_za64_u64_vg2(2, uint32_t_val); + svreadz_ver_za64_u64_vg4(2, uint32_t_val); + svreadz_ver_za128_bf16(2, uint32_t_val); + svreadz_ver_za128_f16(2, uint32_t_val); + svreadz_ver_za128_f32(2, uint32_t_val); + svreadz_ver_za128_f64(2, uint32_t_val); + svreadz_ver_za128_mf8(2, uint32_t_val); + svreadz_ver_za128_s8(2, uint32_t_val); + svreadz_ver_za128_s16(2, uint32_t_val); + svreadz_ver_za128_s32(2, uint32_t_val); + svreadz_ver_za128_s64(2, uint32_t_val); + svreadz_ver_za128_u8(2, uint32_t_val); + svreadz_ver_za128_u16(2, uint32_t_val); + svreadz_ver_za128_u32(2, uint32_t_val); + svreadz_ver_za128_u64(2, uint32_t_val); + svreadz_za8_mf8_vg1x2(uint32_t_val); + svreadz_za8_mf8_vg1x4(uint32_t_val); + svreadz_za8_s8_vg1x2(uint32_t_val); + svreadz_za8_s8_vg1x4(uint32_t_val); + svreadz_za8_u8_vg1x2(uint32_t_val); + svreadz_za8_u8_vg1x4(uint32_t_val); + svreadz_za16_bf16_vg1x2(uint32_t_val); + svreadz_za16_bf16_vg1x4(uint32_t_val); + svreadz_za16_f16_vg1x2(uint32_t_val); + svreadz_za16_f16_vg1x4(uint32_t_val); + svreadz_za16_s16_vg1x2(uint32_t_val); + svreadz_za16_s16_vg1x4(uint32_t_val); + svreadz_za16_u16_vg1x2(uint32_t_val); + svreadz_za16_u16_vg1x4(uint32_t_val); + svreadz_za32_f32_vg1x2(uint32_t_val); + svreadz_za32_f32_vg1x4(uint32_t_val); + svreadz_za32_s32_vg1x2(uint32_t_val); + svreadz_za32_s32_vg1x4(uint32_t_val); + svreadz_za32_u32_vg1x2(uint32_t_val); + svreadz_za32_u32_vg1x4(uint32_t_val); + svreadz_za64_f64_vg1x2(uint32_t_val); + svreadz_za64_f64_vg1x4(uint32_t_val); + svreadz_za64_s64_vg1x2(uint32_t_val); + svreadz_za64_s64_vg1x4(uint32_t_val); + svreadz_za64_u64_vg1x2(uint32_t_val); + svreadz_za64_u64_vg1x4(uint32_t_val); + svzero_za64_vg1x2(uint32_t_val); + svzero_za64_vg1x4(uint32_t_val); + svzero_za64_vg2x1(uint32_t_val); + svzero_za64_vg2x2(uint32_t_val); + svzero_za64_vg2x4(uint32_t_val); + svzero_za64_vg4x1(uint32_t_val); + svzero_za64_vg4x2(uint32_t_val); + svzero_za64_vg4x4(uint32_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible __arm_inout("za"){ + uint32_t uint32_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_mf8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_s8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za8_u8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_bf16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_f16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_s16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za16_u16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_f32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_s32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za32_u32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_f64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_s64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za64_u64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_bf16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_mf8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_hor_za128_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_mf8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_s8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8_vg2(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za8_u8_vg4(0, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_bf16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_f16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_s16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16_vg2(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za16_u16_vg4(1, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_f32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_s32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za32_u32_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_f64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_s64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64_vg2(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za64_u64_vg4(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_bf16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_f64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_mf8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_s64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u8(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u16(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u32(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_ver_za128_u64(2, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_mf8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_mf8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_s8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_s8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_u8_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za8_u8_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_bf16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_bf16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_f16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_f16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_s16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_s16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_u16_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za16_u16_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_f32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_f32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_s32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_s32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_u32_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za32_u32_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_f64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_f64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_s64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_s64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_u64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreadz_za64_u64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg1x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg1x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x1(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg2x4(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x1(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x2(uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzero_za64_vg4x4(uint32_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2_RP___sme_AND_LP_sve2p1_OR_sme2_RP.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2_RP___sme_AND_LP_sve2p1_OR_sme2_RP.c new file mode 100644 index 0000000..a55d46b --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2_RP___sme_AND_LP_sve2p1_OR_sme2_RP.c @@ -0,0 +1,415 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,(sve2p1|sme2)" streaming_guard="sme,(sve2p1|sme2)" flags="feature-dependent" + +void test(void) { + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svboolx2_t svboolx2_t_val; + svboolx4_t svboolx4_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + uint64_t uint64_t_val; + + svbfmlslb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svclamp(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate2(svbool_t_val, svbool_t_val); + svcreate2_b(svbool_t_val, svbool_t_val); + svcreate4(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svcreate4_b(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svdot(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot(svint32_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svdot_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_lane_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val); + svdot_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svget2(svboolx2_t_val, 1); + svget2_b(svboolx2_t_val, 1); + svget4(svboolx4_t_val, 2); + svget4_b(svboolx4_t_val, 2); + svqcvtn_s16(svint32x2_t_val); + svqcvtn_s16_s32_x2(svint32x2_t_val); + svqcvtn_u16(svint32x2_t_val); + svqcvtn_u16(svuint32x2_t_val); + svqcvtn_u16_s32_x2(svint32x2_t_val); + svqcvtn_u16_u32_x2(svuint32x2_t_val); + svqrshrn_n_s16_s32_x2(svint32x2_t_val, 2); + svqrshrn_n_u16_u32_x2(svuint32x2_t_val, 2); + svqrshrn_s16(svint32x2_t_val, 2); + svqrshrn_u16(svuint32x2_t_val, 2); + svqrshrun_n_u16_s32_x2(svint32x2_t_val, 2); + svqrshrun_u16(svint32x2_t_val, 2); + svset2(svboolx2_t_val, 1, svbool_t_val); + svset2_b(svboolx2_t_val, 1, svbool_t_val); + svset4(svboolx4_t_val, 2, svbool_t_val); + svset4_b(svboolx4_t_val, 2, svbool_t_val); + svundef2_b(); + svundef4_b(); + svwhilege_b8_s64_x2(int64_t_val, int64_t_val); + svwhilege_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b8_x2(int64_t_val, int64_t_val); + svwhilege_b8_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_s64_x2(int64_t_val, int64_t_val); + svwhilege_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_x2(int64_t_val, int64_t_val); + svwhilege_b16_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_s64_x2(int64_t_val, int64_t_val); + svwhilege_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_x2(int64_t_val, int64_t_val); + svwhilege_b32_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_s64_x2(int64_t_val, int64_t_val); + svwhilege_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_x2(int64_t_val, int64_t_val); + svwhilege_b64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_x2(int64_t_val, int64_t_val); + svwhilegt_b8_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_x2(int64_t_val, int64_t_val); + svwhilegt_b16_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_x2(int64_t_val, int64_t_val); + svwhilegt_b32_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_s64_x2(int64_t_val, int64_t_val); + svwhilele_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_x2(int64_t_val, int64_t_val); + svwhilele_b8_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_s64_x2(int64_t_val, int64_t_val); + svwhilele_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_x2(int64_t_val, int64_t_val); + svwhilele_b16_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_s64_x2(int64_t_val, int64_t_val); + svwhilele_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_x2(int64_t_val, int64_t_val); + svwhilele_b32_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_s64_x2(int64_t_val, int64_t_val); + svwhilele_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_x2(int64_t_val, int64_t_val); + svwhilele_b64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_x2(int64_t_val, int64_t_val); + svwhilelt_b8_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_x2(int64_t_val, int64_t_val); + svwhilelt_b16_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_x2(int64_t_val, int64_t_val); + svwhilelt_b32_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_x2(uint64_t_val, uint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svboolx2_t svboolx2_t_val; + svboolx4_t svboolx4_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + uint64_t uint64_t_val; + + svbfmlslb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svclamp(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate2(svbool_t_val, svbool_t_val); + svcreate2_b(svbool_t_val, svbool_t_val); + svcreate4(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svcreate4_b(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svdot(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot(svint32_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svdot_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_lane_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val); + svdot_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svget2(svboolx2_t_val, 1); + svget2_b(svboolx2_t_val, 1); + svget4(svboolx4_t_val, 2); + svget4_b(svboolx4_t_val, 2); + svqcvtn_s16(svint32x2_t_val); + svqcvtn_s16_s32_x2(svint32x2_t_val); + svqcvtn_u16(svint32x2_t_val); + svqcvtn_u16(svuint32x2_t_val); + svqcvtn_u16_s32_x2(svint32x2_t_val); + svqcvtn_u16_u32_x2(svuint32x2_t_val); + svqrshrn_n_s16_s32_x2(svint32x2_t_val, 2); + svqrshrn_n_u16_u32_x2(svuint32x2_t_val, 2); + svqrshrn_s16(svint32x2_t_val, 2); + svqrshrn_u16(svuint32x2_t_val, 2); + svqrshrun_n_u16_s32_x2(svint32x2_t_val, 2); + svqrshrun_u16(svint32x2_t_val, 2); + svset2(svboolx2_t_val, 1, svbool_t_val); + svset2_b(svboolx2_t_val, 1, svbool_t_val); + svset4(svboolx4_t_val, 2, svbool_t_val); + svset4_b(svboolx4_t_val, 2, svbool_t_val); + svundef2_b(); + svundef4_b(); + svwhilege_b8_s64_x2(int64_t_val, int64_t_val); + svwhilege_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b8_x2(int64_t_val, int64_t_val); + svwhilege_b8_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_s64_x2(int64_t_val, int64_t_val); + svwhilege_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_x2(int64_t_val, int64_t_val); + svwhilege_b16_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_s64_x2(int64_t_val, int64_t_val); + svwhilege_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_x2(int64_t_val, int64_t_val); + svwhilege_b32_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_s64_x2(int64_t_val, int64_t_val); + svwhilege_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_x2(int64_t_val, int64_t_val); + svwhilege_b64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_x2(int64_t_val, int64_t_val); + svwhilegt_b8_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_x2(int64_t_val, int64_t_val); + svwhilegt_b16_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_x2(int64_t_val, int64_t_val); + svwhilegt_b32_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_s64_x2(int64_t_val, int64_t_val); + svwhilele_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_x2(int64_t_val, int64_t_val); + svwhilele_b8_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_s64_x2(int64_t_val, int64_t_val); + svwhilele_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_x2(int64_t_val, int64_t_val); + svwhilele_b16_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_s64_x2(int64_t_val, int64_t_val); + svwhilele_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_x2(int64_t_val, int64_t_val); + svwhilele_b32_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_s64_x2(int64_t_val, int64_t_val); + svwhilele_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_x2(int64_t_val, int64_t_val); + svwhilele_b64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_x2(int64_t_val, int64_t_val); + svwhilelt_b8_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_x2(int64_t_val, int64_t_val); + svwhilelt_b16_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_x2(int64_t_val, int64_t_val); + svwhilelt_b32_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_x2(uint64_t_val, uint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svboolx2_t svboolx2_t_val; + svboolx4_t svboolx4_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + uint64_t uint64_t_val; + + svbfmlslb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlslt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlslt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svclamp(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate2(svbool_t_val, svbool_t_val); + svcreate2_b(svbool_t_val, svbool_t_val); + svcreate4(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svcreate4_b(svbool_t_val, svbool_t_val, svbool_t_val, svbool_t_val); + svdot(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot(svint32_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svdot_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svdot_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_lane_f32_f16(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 2); + svdot_lane_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val, 2); + svdot_lane_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val, 2); + svdot_s32_s16(svint32_t_val, svint16_t_val, svint16_t_val); + svdot_u32_u16(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svget2(svboolx2_t_val, 1); + svget2_b(svboolx2_t_val, 1); + svget4(svboolx4_t_val, 2); + svget4_b(svboolx4_t_val, 2); + svqcvtn_s16(svint32x2_t_val); + svqcvtn_s16_s32_x2(svint32x2_t_val); + svqcvtn_u16(svint32x2_t_val); + svqcvtn_u16(svuint32x2_t_val); + svqcvtn_u16_s32_x2(svint32x2_t_val); + svqcvtn_u16_u32_x2(svuint32x2_t_val); + svqrshrn_n_s16_s32_x2(svint32x2_t_val, 2); + svqrshrn_n_u16_u32_x2(svuint32x2_t_val, 2); + svqrshrn_s16(svint32x2_t_val, 2); + svqrshrn_u16(svuint32x2_t_val, 2); + svqrshrun_n_u16_s32_x2(svint32x2_t_val, 2); + svqrshrun_u16(svint32x2_t_val, 2); + svset2(svboolx2_t_val, 1, svbool_t_val); + svset2_b(svboolx2_t_val, 1, svbool_t_val); + svset4(svboolx4_t_val, 2, svbool_t_val); + svset4_b(svboolx4_t_val, 2, svbool_t_val); + svundef2_b(); + svundef4_b(); + svwhilege_b8_s64_x2(int64_t_val, int64_t_val); + svwhilege_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b8_x2(int64_t_val, int64_t_val); + svwhilege_b8_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_s64_x2(int64_t_val, int64_t_val); + svwhilege_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b16_x2(int64_t_val, int64_t_val); + svwhilege_b16_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_s64_x2(int64_t_val, int64_t_val); + svwhilege_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b32_x2(int64_t_val, int64_t_val); + svwhilege_b32_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_s64_x2(int64_t_val, int64_t_val); + svwhilege_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilege_b64_x2(int64_t_val, int64_t_val); + svwhilege_b64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b8_x2(int64_t_val, int64_t_val); + svwhilegt_b8_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b16_x2(int64_t_val, int64_t_val); + svwhilegt_b16_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b32_x2(int64_t_val, int64_t_val); + svwhilegt_b32_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilegt_b64_x2(int64_t_val, int64_t_val); + svwhilegt_b64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_s64_x2(int64_t_val, int64_t_val); + svwhilele_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b8_x2(int64_t_val, int64_t_val); + svwhilele_b8_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_s64_x2(int64_t_val, int64_t_val); + svwhilele_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b16_x2(int64_t_val, int64_t_val); + svwhilele_b16_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_s64_x2(int64_t_val, int64_t_val); + svwhilele_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b32_x2(int64_t_val, int64_t_val); + svwhilele_b32_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_s64_x2(int64_t_val, int64_t_val); + svwhilele_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilele_b64_x2(int64_t_val, int64_t_val); + svwhilele_b64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b8_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b8_x2(int64_t_val, int64_t_val); + svwhilelt_b8_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b16_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b16_x2(int64_t_val, int64_t_val); + svwhilelt_b16_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b32_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b32_x2(int64_t_val, int64_t_val); + svwhilelt_b32_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_s64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_u64_x2(uint64_t_val, uint64_t_val); + svwhilelt_b64_x2(int64_t_val, int64_t_val); + svwhilelt_b64_x2(uint64_t_val, uint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2p1_RP___sme_AND_LP_sve2p1_OR_sme2p1_RP.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2p1_RP___sme_AND_LP_sve2p1_OR_sme2p1_RP.c new file mode 100644 index 0000000..43f1575 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme2p1_RP___sme_AND_LP_sve2p1_OR_sme2p1_RP.c @@ -0,0 +1,2317 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2p1 -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,(sve2p1|sme2p1)" streaming_guard="sme,(sve2p1|sme2p1)" flags="feature-dependent" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svaddqv(svbool_t_val, svfloat16_t_val); + svaddqv(svbool_t_val, svfloat32_t_val); + svaddqv(svbool_t_val, svfloat64_t_val); + svaddqv(svbool_t_val, svint8_t_val); + svaddqv(svbool_t_val, svint16_t_val); + svaddqv(svbool_t_val, svint32_t_val); + svaddqv(svbool_t_val, svint64_t_val); + svaddqv(svbool_t_val, svuint8_t_val); + svaddqv(svbool_t_val, svuint16_t_val); + svaddqv(svbool_t_val, svuint32_t_val); + svaddqv(svbool_t_val, svuint64_t_val); + svaddqv_f16(svbool_t_val, svfloat16_t_val); + svaddqv_f32(svbool_t_val, svfloat32_t_val); + svaddqv_f64(svbool_t_val, svfloat64_t_val); + svaddqv_s8(svbool_t_val, svint8_t_val); + svaddqv_s16(svbool_t_val, svint16_t_val); + svaddqv_s32(svbool_t_val, svint32_t_val); + svaddqv_s64(svbool_t_val, svint64_t_val); + svaddqv_u8(svbool_t_val, svuint8_t_val); + svaddqv_u16(svbool_t_val, svuint16_t_val); + svaddqv_u32(svbool_t_val, svuint32_t_val); + svaddqv_u64(svbool_t_val, svuint64_t_val); + svandqv(svbool_t_val, svint8_t_val); + svandqv(svbool_t_val, svint16_t_val); + svandqv(svbool_t_val, svint32_t_val); + svandqv(svbool_t_val, svint64_t_val); + svandqv(svbool_t_val, svuint8_t_val); + svandqv(svbool_t_val, svuint16_t_val); + svandqv(svbool_t_val, svuint32_t_val); + svandqv(svbool_t_val, svuint64_t_val); + svandqv_s8(svbool_t_val, svint8_t_val); + svandqv_s16(svbool_t_val, svint16_t_val); + svandqv_s32(svbool_t_val, svint32_t_val); + svandqv_s64(svbool_t_val, svint64_t_val); + svandqv_u8(svbool_t_val, svuint8_t_val); + svandqv_u16(svbool_t_val, svuint16_t_val); + svandqv_u32(svbool_t_val, svuint32_t_val); + svandqv_u64(svbool_t_val, svuint64_t_val); + svdup_laneq(svbfloat16_t_val, 2); + svdup_laneq(svfloat16_t_val, 2); + svdup_laneq(svfloat32_t_val, 2); + svdup_laneq(svfloat64_t_val, 1); + svdup_laneq(svint8_t_val, 2); + svdup_laneq(svint16_t_val, 2); + svdup_laneq(svint32_t_val, 2); + svdup_laneq(svint64_t_val, 1); + svdup_laneq(svmfloat8_t_val, 2); + svdup_laneq(svuint8_t_val, 2); + svdup_laneq(svuint16_t_val, 2); + svdup_laneq(svuint32_t_val, 2); + svdup_laneq(svuint64_t_val, 1); + svdup_laneq_bf16(svbfloat16_t_val, 2); + svdup_laneq_f16(svfloat16_t_val, 2); + svdup_laneq_f32(svfloat32_t_val, 2); + svdup_laneq_f64(svfloat64_t_val, 1); + svdup_laneq_mf8(svmfloat8_t_val, 2); + svdup_laneq_s8(svint8_t_val, 2); + svdup_laneq_s16(svint16_t_val, 2); + svdup_laneq_s32(svint32_t_val, 2); + svdup_laneq_s64(svint64_t_val, 1); + svdup_laneq_u8(svuint8_t_val, 2); + svdup_laneq_u16(svuint16_t_val, 2); + svdup_laneq_u32(svuint32_t_val, 2); + svdup_laneq_u64(svuint64_t_val, 1); + sveorqv(svbool_t_val, svint8_t_val); + sveorqv(svbool_t_val, svint16_t_val); + sveorqv(svbool_t_val, svint32_t_val); + sveorqv(svbool_t_val, svint64_t_val); + sveorqv(svbool_t_val, svuint8_t_val); + sveorqv(svbool_t_val, svuint16_t_val); + sveorqv(svbool_t_val, svuint32_t_val); + sveorqv(svbool_t_val, svuint64_t_val); + sveorqv_s8(svbool_t_val, svint8_t_val); + sveorqv_s16(svbool_t_val, svint16_t_val); + sveorqv_s32(svbool_t_val, svint32_t_val); + sveorqv_s64(svbool_t_val, svint64_t_val); + sveorqv_u8(svbool_t_val, svuint8_t_val); + sveorqv_u16(svbool_t_val, svuint16_t_val); + sveorqv_u32(svbool_t_val, svuint32_t_val); + sveorqv_u64(svbool_t_val, svuint64_t_val); + svextq(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq(svfloat16_t_val, svfloat16_t_val, 1); + svextq(svfloat32_t_val, svfloat32_t_val, 1); + svextq(svfloat64_t_val, svfloat64_t_val, 1); + svextq(svint8_t_val, svint8_t_val, 1); + svextq(svint16_t_val, svint16_t_val, 1); + svextq(svint32_t_val, svint32_t_val, 1); + svextq(svint64_t_val, svint64_t_val, 1); + svextq(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq(svuint8_t_val, svuint8_t_val, 1); + svextq(svuint16_t_val, svuint16_t_val, 1); + svextq(svuint32_t_val, svuint32_t_val, 1); + svextq(svuint64_t_val, svuint64_t_val, 1); + svextq_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq_f16(svfloat16_t_val, svfloat16_t_val, 1); + svextq_f32(svfloat32_t_val, svfloat32_t_val, 1); + svextq_f64(svfloat64_t_val, svfloat64_t_val, 1); + svextq_mf8(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq_s8(svint8_t_val, svint8_t_val, 1); + svextq_s16(svint16_t_val, svint16_t_val, 1); + svextq_s32(svint32_t_val, svint32_t_val, 1); + svextq_s64(svint64_t_val, svint64_t_val, 1); + svextq_u8(svuint8_t_val, svuint8_t_val, 1); + svextq_u16(svuint16_t_val, svuint16_t_val, 1); + svextq_u32(svuint32_t_val, svuint32_t_val, 1); + svextq_u64(svuint64_t_val, svuint64_t_val, 1); + svld2q(svbool_t_val, bfloat16_t_ptr_val); + svld2q(svbool_t_val, float16_t_ptr_val); + svld2q(svbool_t_val, float32_t_ptr_val); + svld2q(svbool_t_val, float64_t_ptr_val); + svld2q(svbool_t_val, int8_t_ptr_val); + svld2q(svbool_t_val, int16_t_ptr_val); + svld2q(svbool_t_val, int32_t_ptr_val); + svld2q(svbool_t_val, int64_t_ptr_val); + svld2q(svbool_t_val, mfloat8_t_ptr_val); + svld2q(svbool_t_val, uint8_t_ptr_val); + svld2q(svbool_t_val, uint16_t_ptr_val); + svld2q(svbool_t_val, uint32_t_ptr_val); + svld2q(svbool_t_val, uint64_t_ptr_val); + svld2q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2q_f16(svbool_t_val, float16_t_ptr_val); + svld2q_f32(svbool_t_val, float32_t_ptr_val); + svld2q_f64(svbool_t_val, float64_t_ptr_val); + svld2q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2q_s8(svbool_t_val, int8_t_ptr_val); + svld2q_s16(svbool_t_val, int16_t_ptr_val); + svld2q_s32(svbool_t_val, int32_t_ptr_val); + svld2q_s64(svbool_t_val, int64_t_ptr_val); + svld2q_u8(svbool_t_val, uint8_t_ptr_val); + svld2q_u16(svbool_t_val, uint16_t_ptr_val); + svld2q_u32(svbool_t_val, uint32_t_ptr_val); + svld2q_u64(svbool_t_val, uint64_t_ptr_val); + svld2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q(svbool_t_val, bfloat16_t_ptr_val); + svld3q(svbool_t_val, float16_t_ptr_val); + svld3q(svbool_t_val, float32_t_ptr_val); + svld3q(svbool_t_val, float64_t_ptr_val); + svld3q(svbool_t_val, int8_t_ptr_val); + svld3q(svbool_t_val, int16_t_ptr_val); + svld3q(svbool_t_val, int32_t_ptr_val); + svld3q(svbool_t_val, int64_t_ptr_val); + svld3q(svbool_t_val, mfloat8_t_ptr_val); + svld3q(svbool_t_val, uint8_t_ptr_val); + svld3q(svbool_t_val, uint16_t_ptr_val); + svld3q(svbool_t_val, uint32_t_ptr_val); + svld3q(svbool_t_val, uint64_t_ptr_val); + svld3q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3q_f16(svbool_t_val, float16_t_ptr_val); + svld3q_f32(svbool_t_val, float32_t_ptr_val); + svld3q_f64(svbool_t_val, float64_t_ptr_val); + svld3q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3q_s8(svbool_t_val, int8_t_ptr_val); + svld3q_s16(svbool_t_val, int16_t_ptr_val); + svld3q_s32(svbool_t_val, int32_t_ptr_val); + svld3q_s64(svbool_t_val, int64_t_ptr_val); + svld3q_u8(svbool_t_val, uint8_t_ptr_val); + svld3q_u16(svbool_t_val, uint16_t_ptr_val); + svld3q_u32(svbool_t_val, uint32_t_ptr_val); + svld3q_u64(svbool_t_val, uint64_t_ptr_val); + svld3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q(svbool_t_val, bfloat16_t_ptr_val); + svld4q(svbool_t_val, float16_t_ptr_val); + svld4q(svbool_t_val, float32_t_ptr_val); + svld4q(svbool_t_val, float64_t_ptr_val); + svld4q(svbool_t_val, int8_t_ptr_val); + svld4q(svbool_t_val, int16_t_ptr_val); + svld4q(svbool_t_val, int32_t_ptr_val); + svld4q(svbool_t_val, int64_t_ptr_val); + svld4q(svbool_t_val, mfloat8_t_ptr_val); + svld4q(svbool_t_val, uint8_t_ptr_val); + svld4q(svbool_t_val, uint16_t_ptr_val); + svld4q(svbool_t_val, uint32_t_ptr_val); + svld4q(svbool_t_val, uint64_t_ptr_val); + svld4q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4q_f16(svbool_t_val, float16_t_ptr_val); + svld4q_f32(svbool_t_val, float32_t_ptr_val); + svld4q_f64(svbool_t_val, float64_t_ptr_val); + svld4q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4q_s8(svbool_t_val, int8_t_ptr_val); + svld4q_s16(svbool_t_val, int16_t_ptr_val); + svld4q_s32(svbool_t_val, int32_t_ptr_val); + svld4q_s64(svbool_t_val, int64_t_ptr_val); + svld4q_u8(svbool_t_val, uint8_t_ptr_val); + svld4q_u16(svbool_t_val, uint16_t_ptr_val); + svld4q_u32(svbool_t_val, uint32_t_ptr_val); + svld4q_u64(svbool_t_val, uint64_t_ptr_val); + svld4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svmaxnmqv(svbool_t_val, svfloat16_t_val); + svmaxnmqv(svbool_t_val, svfloat32_t_val); + svmaxnmqv(svbool_t_val, svfloat64_t_val); + svmaxnmqv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmqv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svfloat16_t_val); + svmaxqv(svbool_t_val, svfloat32_t_val); + svmaxqv(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svint8_t_val); + svmaxqv(svbool_t_val, svint16_t_val); + svmaxqv(svbool_t_val, svint32_t_val); + svmaxqv(svbool_t_val, svint64_t_val); + svmaxqv(svbool_t_val, svuint8_t_val); + svmaxqv(svbool_t_val, svuint16_t_val); + svmaxqv(svbool_t_val, svuint32_t_val); + svmaxqv(svbool_t_val, svuint64_t_val); + svmaxqv_f16(svbool_t_val, svfloat16_t_val); + svmaxqv_f32(svbool_t_val, svfloat32_t_val); + svmaxqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv_s8(svbool_t_val, svint8_t_val); + svmaxqv_s16(svbool_t_val, svint16_t_val); + svmaxqv_s32(svbool_t_val, svint32_t_val); + svmaxqv_s64(svbool_t_val, svint64_t_val); + svmaxqv_u8(svbool_t_val, svuint8_t_val); + svmaxqv_u16(svbool_t_val, svuint16_t_val); + svmaxqv_u32(svbool_t_val, svuint32_t_val); + svmaxqv_u64(svbool_t_val, svuint64_t_val); + svminnmqv(svbool_t_val, svfloat16_t_val); + svminnmqv(svbool_t_val, svfloat32_t_val); + svminnmqv(svbool_t_val, svfloat64_t_val); + svminnmqv_f16(svbool_t_val, svfloat16_t_val); + svminnmqv_f32(svbool_t_val, svfloat32_t_val); + svminnmqv_f64(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svfloat16_t_val); + svminqv(svbool_t_val, svfloat32_t_val); + svminqv(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svint8_t_val); + svminqv(svbool_t_val, svint16_t_val); + svminqv(svbool_t_val, svint32_t_val); + svminqv(svbool_t_val, svint64_t_val); + svminqv(svbool_t_val, svuint8_t_val); + svminqv(svbool_t_val, svuint16_t_val); + svminqv(svbool_t_val, svuint32_t_val); + svminqv(svbool_t_val, svuint64_t_val); + svminqv_f16(svbool_t_val, svfloat16_t_val); + svminqv_f32(svbool_t_val, svfloat32_t_val); + svminqv_f64(svbool_t_val, svfloat64_t_val); + svminqv_s8(svbool_t_val, svint8_t_val); + svminqv_s16(svbool_t_val, svint16_t_val); + svminqv_s32(svbool_t_val, svint32_t_val); + svminqv_s64(svbool_t_val, svint64_t_val); + svminqv_u8(svbool_t_val, svuint8_t_val); + svminqv_u16(svbool_t_val, svuint16_t_val); + svminqv_u32(svbool_t_val, svuint32_t_val); + svminqv_u64(svbool_t_val, svuint64_t_val); + svorqv(svbool_t_val, svint8_t_val); + svorqv(svbool_t_val, svint16_t_val); + svorqv(svbool_t_val, svint32_t_val); + svorqv(svbool_t_val, svint64_t_val); + svorqv(svbool_t_val, svuint8_t_val); + svorqv(svbool_t_val, svuint16_t_val); + svorqv(svbool_t_val, svuint32_t_val); + svorqv(svbool_t_val, svuint64_t_val); + svorqv_s8(svbool_t_val, svint8_t_val); + svorqv_s16(svbool_t_val, svint16_t_val); + svorqv_s32(svbool_t_val, svint32_t_val); + svorqv_s64(svbool_t_val, svint64_t_val); + svorqv_u8(svbool_t_val, svuint8_t_val); + svorqv_u16(svbool_t_val, svuint16_t_val); + svorqv_u32(svbool_t_val, svuint32_t_val); + svorqv_u64(svbool_t_val, svuint64_t_val); + svpmov(svint8_t_val); + svpmov(svint16_t_val); + svpmov(svint32_t_val); + svpmov(svint64_t_val); + svpmov(svuint8_t_val); + svpmov(svuint16_t_val); + svpmov(svuint32_t_val); + svpmov(svuint64_t_val); + svpmov_lane(svint8_t_val, 0); + svpmov_lane(svint16_t_val, 1); + svpmov_lane(svint32_t_val, 2); + svpmov_lane(svint64_t_val, 2); + svpmov_lane(svuint8_t_val, 0); + svpmov_lane(svuint16_t_val, 1); + svpmov_lane(svuint32_t_val, 2); + svpmov_lane(svuint64_t_val, 2); + svpmov_lane_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint64_t_val, svbool_t_val, 2); + svpmov_lane_s8(svint8_t_val, 0); + svpmov_lane_s16(svint16_t_val, 1); + svpmov_lane_s16_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_s32(svint32_t_val, 2); + svpmov_lane_s32_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_s64(svint64_t_val, 2); + svpmov_lane_s64_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_u8(svuint8_t_val, 0); + svpmov_lane_u16(svuint16_t_val, 1); + svpmov_lane_u16_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_u32(svuint32_t_val, 2); + svpmov_lane_u32_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_u64(svuint64_t_val, 2); + svpmov_lane_u64_m(svuint64_t_val, svbool_t_val, 2); + svpmov_s8(svint8_t_val); + svpmov_s8_z(svbool_t_val); + svpmov_s16(svint16_t_val); + svpmov_s16_z(svbool_t_val); + svpmov_s32(svint32_t_val); + svpmov_s32_z(svbool_t_val); + svpmov_s64(svint64_t_val); + svpmov_s64_z(svbool_t_val); + svpmov_u8(svuint8_t_val); + svpmov_u8_z(svbool_t_val); + svpmov_u16(svuint16_t_val); + svpmov_u16_z(svbool_t_val); + svpmov_u32(svuint32_t_val); + svpmov_u32_z(svbool_t_val); + svpmov_u64(svuint64_t_val); + svpmov_u64_z(svbool_t_val); + svst2q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svtblq(svbfloat16_t_val, svuint16_t_val); + svtblq(svfloat16_t_val, svuint16_t_val); + svtblq(svfloat32_t_val, svuint32_t_val); + svtblq(svfloat64_t_val, svuint64_t_val); + svtblq(svint8_t_val, svuint8_t_val); + svtblq(svint16_t_val, svuint16_t_val); + svtblq(svint32_t_val, svuint32_t_val); + svtblq(svint64_t_val, svuint64_t_val); + svtblq(svmfloat8_t_val, svuint8_t_val); + svtblq(svuint8_t_val, svuint8_t_val); + svtblq(svuint16_t_val, svuint16_t_val); + svtblq(svuint32_t_val, svuint32_t_val); + svtblq(svuint64_t_val, svuint64_t_val); + svtblq_bf16(svbfloat16_t_val, svuint16_t_val); + svtblq_f16(svfloat16_t_val, svuint16_t_val); + svtblq_f32(svfloat32_t_val, svuint32_t_val); + svtblq_f64(svfloat64_t_val, svuint64_t_val); + svtblq_mf8(svmfloat8_t_val, svuint8_t_val); + svtblq_s8(svint8_t_val, svuint8_t_val); + svtblq_s16(svint16_t_val, svuint16_t_val); + svtblq_s32(svint32_t_val, svuint32_t_val); + svtblq_s64(svint64_t_val, svuint64_t_val); + svtblq_u8(svuint8_t_val, svuint8_t_val); + svtblq_u16(svuint16_t_val, svuint16_t_val); + svtblq_u32(svuint32_t_val, svuint32_t_val); + svtblq_u64(svuint64_t_val, svuint64_t_val); + svtbxq(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbxq_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq_mf8(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuzpq1(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1(svfloat16_t_val, svfloat16_t_val); + svuzpq1(svfloat32_t_val, svfloat32_t_val); + svuzpq1(svfloat64_t_val, svfloat64_t_val); + svuzpq1(svint8_t_val, svint8_t_val); + svuzpq1(svint16_t_val, svint16_t_val); + svuzpq1(svint32_t_val, svint32_t_val); + svuzpq1(svint64_t_val, svint64_t_val); + svuzpq1(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1(svuint8_t_val, svuint8_t_val); + svuzpq1(svuint16_t_val, svuint16_t_val); + svuzpq1(svuint32_t_val, svuint32_t_val); + svuzpq1(svuint64_t_val, svuint64_t_val); + svuzpq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq1_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq1_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1_s8(svint8_t_val, svint8_t_val); + svuzpq1_s16(svint16_t_val, svint16_t_val); + svuzpq1_s32(svint32_t_val, svint32_t_val); + svuzpq1_s64(svint64_t_val, svint64_t_val); + svuzpq1_u8(svuint8_t_val, svuint8_t_val); + svuzpq1_u16(svuint16_t_val, svuint16_t_val); + svuzpq1_u32(svuint32_t_val, svuint32_t_val); + svuzpq1_u64(svuint64_t_val, svuint64_t_val); + svuzpq2(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2(svfloat16_t_val, svfloat16_t_val); + svuzpq2(svfloat32_t_val, svfloat32_t_val); + svuzpq2(svfloat64_t_val, svfloat64_t_val); + svuzpq2(svint8_t_val, svint8_t_val); + svuzpq2(svint16_t_val, svint16_t_val); + svuzpq2(svint32_t_val, svint32_t_val); + svuzpq2(svint64_t_val, svint64_t_val); + svuzpq2(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2(svuint8_t_val, svuint8_t_val); + svuzpq2(svuint16_t_val, svuint16_t_val); + svuzpq2(svuint32_t_val, svuint32_t_val); + svuzpq2(svuint64_t_val, svuint64_t_val); + svuzpq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq2_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq2_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2_s8(svint8_t_val, svint8_t_val); + svuzpq2_s16(svint16_t_val, svint16_t_val); + svuzpq2_s32(svint32_t_val, svint32_t_val); + svuzpq2_s64(svint64_t_val, svint64_t_val); + svuzpq2_u8(svuint8_t_val, svuint8_t_val); + svuzpq2_u16(svuint16_t_val, svuint16_t_val); + svuzpq2_u32(svuint32_t_val, svuint32_t_val); + svuzpq2_u64(svuint64_t_val, svuint64_t_val); + svzipq1(svbfloat16_t_val, svbfloat16_t_val); + svzipq1(svfloat16_t_val, svfloat16_t_val); + svzipq1(svfloat32_t_val, svfloat32_t_val); + svzipq1(svfloat64_t_val, svfloat64_t_val); + svzipq1(svint8_t_val, svint8_t_val); + svzipq1(svint16_t_val, svint16_t_val); + svzipq1(svint32_t_val, svint32_t_val); + svzipq1(svint64_t_val, svint64_t_val); + svzipq1(svmfloat8_t_val, svmfloat8_t_val); + svzipq1(svuint8_t_val, svuint8_t_val); + svzipq1(svuint16_t_val, svuint16_t_val); + svzipq1(svuint32_t_val, svuint32_t_val); + svzipq1(svuint64_t_val, svuint64_t_val); + svzipq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq1_f16(svfloat16_t_val, svfloat16_t_val); + svzipq1_f32(svfloat32_t_val, svfloat32_t_val); + svzipq1_f64(svfloat64_t_val, svfloat64_t_val); + svzipq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq1_s8(svint8_t_val, svint8_t_val); + svzipq1_s16(svint16_t_val, svint16_t_val); + svzipq1_s32(svint32_t_val, svint32_t_val); + svzipq1_s64(svint64_t_val, svint64_t_val); + svzipq1_u8(svuint8_t_val, svuint8_t_val); + svzipq1_u16(svuint16_t_val, svuint16_t_val); + svzipq1_u32(svuint32_t_val, svuint32_t_val); + svzipq1_u64(svuint64_t_val, svuint64_t_val); + svzipq2(svbfloat16_t_val, svbfloat16_t_val); + svzipq2(svfloat16_t_val, svfloat16_t_val); + svzipq2(svfloat32_t_val, svfloat32_t_val); + svzipq2(svfloat64_t_val, svfloat64_t_val); + svzipq2(svint8_t_val, svint8_t_val); + svzipq2(svint16_t_val, svint16_t_val); + svzipq2(svint32_t_val, svint32_t_val); + svzipq2(svint64_t_val, svint64_t_val); + svzipq2(svmfloat8_t_val, svmfloat8_t_val); + svzipq2(svuint8_t_val, svuint8_t_val); + svzipq2(svuint16_t_val, svuint16_t_val); + svzipq2(svuint32_t_val, svuint32_t_val); + svzipq2(svuint64_t_val, svuint64_t_val); + svzipq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq2_f16(svfloat16_t_val, svfloat16_t_val); + svzipq2_f32(svfloat32_t_val, svfloat32_t_val); + svzipq2_f64(svfloat64_t_val, svfloat64_t_val); + svzipq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq2_s8(svint8_t_val, svint8_t_val); + svzipq2_s16(svint16_t_val, svint16_t_val); + svzipq2_s32(svint32_t_val, svint32_t_val); + svzipq2_s64(svint64_t_val, svint64_t_val); + svzipq2_u8(svuint8_t_val, svuint8_t_val); + svzipq2_u16(svuint16_t_val, svuint16_t_val); + svzipq2_u32(svuint32_t_val, svuint32_t_val); + svzipq2_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svaddqv(svbool_t_val, svfloat16_t_val); + svaddqv(svbool_t_val, svfloat32_t_val); + svaddqv(svbool_t_val, svfloat64_t_val); + svaddqv(svbool_t_val, svint8_t_val); + svaddqv(svbool_t_val, svint16_t_val); + svaddqv(svbool_t_val, svint32_t_val); + svaddqv(svbool_t_val, svint64_t_val); + svaddqv(svbool_t_val, svuint8_t_val); + svaddqv(svbool_t_val, svuint16_t_val); + svaddqv(svbool_t_val, svuint32_t_val); + svaddqv(svbool_t_val, svuint64_t_val); + svaddqv_f16(svbool_t_val, svfloat16_t_val); + svaddqv_f32(svbool_t_val, svfloat32_t_val); + svaddqv_f64(svbool_t_val, svfloat64_t_val); + svaddqv_s8(svbool_t_val, svint8_t_val); + svaddqv_s16(svbool_t_val, svint16_t_val); + svaddqv_s32(svbool_t_val, svint32_t_val); + svaddqv_s64(svbool_t_val, svint64_t_val); + svaddqv_u8(svbool_t_val, svuint8_t_val); + svaddqv_u16(svbool_t_val, svuint16_t_val); + svaddqv_u32(svbool_t_val, svuint32_t_val); + svaddqv_u64(svbool_t_val, svuint64_t_val); + svandqv(svbool_t_val, svint8_t_val); + svandqv(svbool_t_val, svint16_t_val); + svandqv(svbool_t_val, svint32_t_val); + svandqv(svbool_t_val, svint64_t_val); + svandqv(svbool_t_val, svuint8_t_val); + svandqv(svbool_t_val, svuint16_t_val); + svandqv(svbool_t_val, svuint32_t_val); + svandqv(svbool_t_val, svuint64_t_val); + svandqv_s8(svbool_t_val, svint8_t_val); + svandqv_s16(svbool_t_val, svint16_t_val); + svandqv_s32(svbool_t_val, svint32_t_val); + svandqv_s64(svbool_t_val, svint64_t_val); + svandqv_u8(svbool_t_val, svuint8_t_val); + svandqv_u16(svbool_t_val, svuint16_t_val); + svandqv_u32(svbool_t_val, svuint32_t_val); + svandqv_u64(svbool_t_val, svuint64_t_val); + svdup_laneq(svbfloat16_t_val, 2); + svdup_laneq(svfloat16_t_val, 2); + svdup_laneq(svfloat32_t_val, 2); + svdup_laneq(svfloat64_t_val, 1); + svdup_laneq(svint8_t_val, 2); + svdup_laneq(svint16_t_val, 2); + svdup_laneq(svint32_t_val, 2); + svdup_laneq(svint64_t_val, 1); + svdup_laneq(svmfloat8_t_val, 2); + svdup_laneq(svuint8_t_val, 2); + svdup_laneq(svuint16_t_val, 2); + svdup_laneq(svuint32_t_val, 2); + svdup_laneq(svuint64_t_val, 1); + svdup_laneq_bf16(svbfloat16_t_val, 2); + svdup_laneq_f16(svfloat16_t_val, 2); + svdup_laneq_f32(svfloat32_t_val, 2); + svdup_laneq_f64(svfloat64_t_val, 1); + svdup_laneq_mf8(svmfloat8_t_val, 2); + svdup_laneq_s8(svint8_t_val, 2); + svdup_laneq_s16(svint16_t_val, 2); + svdup_laneq_s32(svint32_t_val, 2); + svdup_laneq_s64(svint64_t_val, 1); + svdup_laneq_u8(svuint8_t_val, 2); + svdup_laneq_u16(svuint16_t_val, 2); + svdup_laneq_u32(svuint32_t_val, 2); + svdup_laneq_u64(svuint64_t_val, 1); + sveorqv(svbool_t_val, svint8_t_val); + sveorqv(svbool_t_val, svint16_t_val); + sveorqv(svbool_t_val, svint32_t_val); + sveorqv(svbool_t_val, svint64_t_val); + sveorqv(svbool_t_val, svuint8_t_val); + sveorqv(svbool_t_val, svuint16_t_val); + sveorqv(svbool_t_val, svuint32_t_val); + sveorqv(svbool_t_val, svuint64_t_val); + sveorqv_s8(svbool_t_val, svint8_t_val); + sveorqv_s16(svbool_t_val, svint16_t_val); + sveorqv_s32(svbool_t_val, svint32_t_val); + sveorqv_s64(svbool_t_val, svint64_t_val); + sveorqv_u8(svbool_t_val, svuint8_t_val); + sveorqv_u16(svbool_t_val, svuint16_t_val); + sveorqv_u32(svbool_t_val, svuint32_t_val); + sveorqv_u64(svbool_t_val, svuint64_t_val); + svextq(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq(svfloat16_t_val, svfloat16_t_val, 1); + svextq(svfloat32_t_val, svfloat32_t_val, 1); + svextq(svfloat64_t_val, svfloat64_t_val, 1); + svextq(svint8_t_val, svint8_t_val, 1); + svextq(svint16_t_val, svint16_t_val, 1); + svextq(svint32_t_val, svint32_t_val, 1); + svextq(svint64_t_val, svint64_t_val, 1); + svextq(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq(svuint8_t_val, svuint8_t_val, 1); + svextq(svuint16_t_val, svuint16_t_val, 1); + svextq(svuint32_t_val, svuint32_t_val, 1); + svextq(svuint64_t_val, svuint64_t_val, 1); + svextq_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq_f16(svfloat16_t_val, svfloat16_t_val, 1); + svextq_f32(svfloat32_t_val, svfloat32_t_val, 1); + svextq_f64(svfloat64_t_val, svfloat64_t_val, 1); + svextq_mf8(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq_s8(svint8_t_val, svint8_t_val, 1); + svextq_s16(svint16_t_val, svint16_t_val, 1); + svextq_s32(svint32_t_val, svint32_t_val, 1); + svextq_s64(svint64_t_val, svint64_t_val, 1); + svextq_u8(svuint8_t_val, svuint8_t_val, 1); + svextq_u16(svuint16_t_val, svuint16_t_val, 1); + svextq_u32(svuint32_t_val, svuint32_t_val, 1); + svextq_u64(svuint64_t_val, svuint64_t_val, 1); + svld2q(svbool_t_val, bfloat16_t_ptr_val); + svld2q(svbool_t_val, float16_t_ptr_val); + svld2q(svbool_t_val, float32_t_ptr_val); + svld2q(svbool_t_val, float64_t_ptr_val); + svld2q(svbool_t_val, int8_t_ptr_val); + svld2q(svbool_t_val, int16_t_ptr_val); + svld2q(svbool_t_val, int32_t_ptr_val); + svld2q(svbool_t_val, int64_t_ptr_val); + svld2q(svbool_t_val, mfloat8_t_ptr_val); + svld2q(svbool_t_val, uint8_t_ptr_val); + svld2q(svbool_t_val, uint16_t_ptr_val); + svld2q(svbool_t_val, uint32_t_ptr_val); + svld2q(svbool_t_val, uint64_t_ptr_val); + svld2q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2q_f16(svbool_t_val, float16_t_ptr_val); + svld2q_f32(svbool_t_val, float32_t_ptr_val); + svld2q_f64(svbool_t_val, float64_t_ptr_val); + svld2q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2q_s8(svbool_t_val, int8_t_ptr_val); + svld2q_s16(svbool_t_val, int16_t_ptr_val); + svld2q_s32(svbool_t_val, int32_t_ptr_val); + svld2q_s64(svbool_t_val, int64_t_ptr_val); + svld2q_u8(svbool_t_val, uint8_t_ptr_val); + svld2q_u16(svbool_t_val, uint16_t_ptr_val); + svld2q_u32(svbool_t_val, uint32_t_ptr_val); + svld2q_u64(svbool_t_val, uint64_t_ptr_val); + svld2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q(svbool_t_val, bfloat16_t_ptr_val); + svld3q(svbool_t_val, float16_t_ptr_val); + svld3q(svbool_t_val, float32_t_ptr_val); + svld3q(svbool_t_val, float64_t_ptr_val); + svld3q(svbool_t_val, int8_t_ptr_val); + svld3q(svbool_t_val, int16_t_ptr_val); + svld3q(svbool_t_val, int32_t_ptr_val); + svld3q(svbool_t_val, int64_t_ptr_val); + svld3q(svbool_t_val, mfloat8_t_ptr_val); + svld3q(svbool_t_val, uint8_t_ptr_val); + svld3q(svbool_t_val, uint16_t_ptr_val); + svld3q(svbool_t_val, uint32_t_ptr_val); + svld3q(svbool_t_val, uint64_t_ptr_val); + svld3q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3q_f16(svbool_t_val, float16_t_ptr_val); + svld3q_f32(svbool_t_val, float32_t_ptr_val); + svld3q_f64(svbool_t_val, float64_t_ptr_val); + svld3q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3q_s8(svbool_t_val, int8_t_ptr_val); + svld3q_s16(svbool_t_val, int16_t_ptr_val); + svld3q_s32(svbool_t_val, int32_t_ptr_val); + svld3q_s64(svbool_t_val, int64_t_ptr_val); + svld3q_u8(svbool_t_val, uint8_t_ptr_val); + svld3q_u16(svbool_t_val, uint16_t_ptr_val); + svld3q_u32(svbool_t_val, uint32_t_ptr_val); + svld3q_u64(svbool_t_val, uint64_t_ptr_val); + svld3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q(svbool_t_val, bfloat16_t_ptr_val); + svld4q(svbool_t_val, float16_t_ptr_val); + svld4q(svbool_t_val, float32_t_ptr_val); + svld4q(svbool_t_val, float64_t_ptr_val); + svld4q(svbool_t_val, int8_t_ptr_val); + svld4q(svbool_t_val, int16_t_ptr_val); + svld4q(svbool_t_val, int32_t_ptr_val); + svld4q(svbool_t_val, int64_t_ptr_val); + svld4q(svbool_t_val, mfloat8_t_ptr_val); + svld4q(svbool_t_val, uint8_t_ptr_val); + svld4q(svbool_t_val, uint16_t_ptr_val); + svld4q(svbool_t_val, uint32_t_ptr_val); + svld4q(svbool_t_val, uint64_t_ptr_val); + svld4q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4q_f16(svbool_t_val, float16_t_ptr_val); + svld4q_f32(svbool_t_val, float32_t_ptr_val); + svld4q_f64(svbool_t_val, float64_t_ptr_val); + svld4q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4q_s8(svbool_t_val, int8_t_ptr_val); + svld4q_s16(svbool_t_val, int16_t_ptr_val); + svld4q_s32(svbool_t_val, int32_t_ptr_val); + svld4q_s64(svbool_t_val, int64_t_ptr_val); + svld4q_u8(svbool_t_val, uint8_t_ptr_val); + svld4q_u16(svbool_t_val, uint16_t_ptr_val); + svld4q_u32(svbool_t_val, uint32_t_ptr_val); + svld4q_u64(svbool_t_val, uint64_t_ptr_val); + svld4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svmaxnmqv(svbool_t_val, svfloat16_t_val); + svmaxnmqv(svbool_t_val, svfloat32_t_val); + svmaxnmqv(svbool_t_val, svfloat64_t_val); + svmaxnmqv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmqv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svfloat16_t_val); + svmaxqv(svbool_t_val, svfloat32_t_val); + svmaxqv(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svint8_t_val); + svmaxqv(svbool_t_val, svint16_t_val); + svmaxqv(svbool_t_val, svint32_t_val); + svmaxqv(svbool_t_val, svint64_t_val); + svmaxqv(svbool_t_val, svuint8_t_val); + svmaxqv(svbool_t_val, svuint16_t_val); + svmaxqv(svbool_t_val, svuint32_t_val); + svmaxqv(svbool_t_val, svuint64_t_val); + svmaxqv_f16(svbool_t_val, svfloat16_t_val); + svmaxqv_f32(svbool_t_val, svfloat32_t_val); + svmaxqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv_s8(svbool_t_val, svint8_t_val); + svmaxqv_s16(svbool_t_val, svint16_t_val); + svmaxqv_s32(svbool_t_val, svint32_t_val); + svmaxqv_s64(svbool_t_val, svint64_t_val); + svmaxqv_u8(svbool_t_val, svuint8_t_val); + svmaxqv_u16(svbool_t_val, svuint16_t_val); + svmaxqv_u32(svbool_t_val, svuint32_t_val); + svmaxqv_u64(svbool_t_val, svuint64_t_val); + svminnmqv(svbool_t_val, svfloat16_t_val); + svminnmqv(svbool_t_val, svfloat32_t_val); + svminnmqv(svbool_t_val, svfloat64_t_val); + svminnmqv_f16(svbool_t_val, svfloat16_t_val); + svminnmqv_f32(svbool_t_val, svfloat32_t_val); + svminnmqv_f64(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svfloat16_t_val); + svminqv(svbool_t_val, svfloat32_t_val); + svminqv(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svint8_t_val); + svminqv(svbool_t_val, svint16_t_val); + svminqv(svbool_t_val, svint32_t_val); + svminqv(svbool_t_val, svint64_t_val); + svminqv(svbool_t_val, svuint8_t_val); + svminqv(svbool_t_val, svuint16_t_val); + svminqv(svbool_t_val, svuint32_t_val); + svminqv(svbool_t_val, svuint64_t_val); + svminqv_f16(svbool_t_val, svfloat16_t_val); + svminqv_f32(svbool_t_val, svfloat32_t_val); + svminqv_f64(svbool_t_val, svfloat64_t_val); + svminqv_s8(svbool_t_val, svint8_t_val); + svminqv_s16(svbool_t_val, svint16_t_val); + svminqv_s32(svbool_t_val, svint32_t_val); + svminqv_s64(svbool_t_val, svint64_t_val); + svminqv_u8(svbool_t_val, svuint8_t_val); + svminqv_u16(svbool_t_val, svuint16_t_val); + svminqv_u32(svbool_t_val, svuint32_t_val); + svminqv_u64(svbool_t_val, svuint64_t_val); + svorqv(svbool_t_val, svint8_t_val); + svorqv(svbool_t_val, svint16_t_val); + svorqv(svbool_t_val, svint32_t_val); + svorqv(svbool_t_val, svint64_t_val); + svorqv(svbool_t_val, svuint8_t_val); + svorqv(svbool_t_val, svuint16_t_val); + svorqv(svbool_t_val, svuint32_t_val); + svorqv(svbool_t_val, svuint64_t_val); + svorqv_s8(svbool_t_val, svint8_t_val); + svorqv_s16(svbool_t_val, svint16_t_val); + svorqv_s32(svbool_t_val, svint32_t_val); + svorqv_s64(svbool_t_val, svint64_t_val); + svorqv_u8(svbool_t_val, svuint8_t_val); + svorqv_u16(svbool_t_val, svuint16_t_val); + svorqv_u32(svbool_t_val, svuint32_t_val); + svorqv_u64(svbool_t_val, svuint64_t_val); + svpmov(svint8_t_val); + svpmov(svint16_t_val); + svpmov(svint32_t_val); + svpmov(svint64_t_val); + svpmov(svuint8_t_val); + svpmov(svuint16_t_val); + svpmov(svuint32_t_val); + svpmov(svuint64_t_val); + svpmov_lane(svint8_t_val, 0); + svpmov_lane(svint16_t_val, 1); + svpmov_lane(svint32_t_val, 2); + svpmov_lane(svint64_t_val, 2); + svpmov_lane(svuint8_t_val, 0); + svpmov_lane(svuint16_t_val, 1); + svpmov_lane(svuint32_t_val, 2); + svpmov_lane(svuint64_t_val, 2); + svpmov_lane_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint64_t_val, svbool_t_val, 2); + svpmov_lane_s8(svint8_t_val, 0); + svpmov_lane_s16(svint16_t_val, 1); + svpmov_lane_s16_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_s32(svint32_t_val, 2); + svpmov_lane_s32_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_s64(svint64_t_val, 2); + svpmov_lane_s64_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_u8(svuint8_t_val, 0); + svpmov_lane_u16(svuint16_t_val, 1); + svpmov_lane_u16_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_u32(svuint32_t_val, 2); + svpmov_lane_u32_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_u64(svuint64_t_val, 2); + svpmov_lane_u64_m(svuint64_t_val, svbool_t_val, 2); + svpmov_s8(svint8_t_val); + svpmov_s8_z(svbool_t_val); + svpmov_s16(svint16_t_val); + svpmov_s16_z(svbool_t_val); + svpmov_s32(svint32_t_val); + svpmov_s32_z(svbool_t_val); + svpmov_s64(svint64_t_val); + svpmov_s64_z(svbool_t_val); + svpmov_u8(svuint8_t_val); + svpmov_u8_z(svbool_t_val); + svpmov_u16(svuint16_t_val); + svpmov_u16_z(svbool_t_val); + svpmov_u32(svuint32_t_val); + svpmov_u32_z(svbool_t_val); + svpmov_u64(svuint64_t_val); + svpmov_u64_z(svbool_t_val); + svst2q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svtblq(svbfloat16_t_val, svuint16_t_val); + svtblq(svfloat16_t_val, svuint16_t_val); + svtblq(svfloat32_t_val, svuint32_t_val); + svtblq(svfloat64_t_val, svuint64_t_val); + svtblq(svint8_t_val, svuint8_t_val); + svtblq(svint16_t_val, svuint16_t_val); + svtblq(svint32_t_val, svuint32_t_val); + svtblq(svint64_t_val, svuint64_t_val); + svtblq(svmfloat8_t_val, svuint8_t_val); + svtblq(svuint8_t_val, svuint8_t_val); + svtblq(svuint16_t_val, svuint16_t_val); + svtblq(svuint32_t_val, svuint32_t_val); + svtblq(svuint64_t_val, svuint64_t_val); + svtblq_bf16(svbfloat16_t_val, svuint16_t_val); + svtblq_f16(svfloat16_t_val, svuint16_t_val); + svtblq_f32(svfloat32_t_val, svuint32_t_val); + svtblq_f64(svfloat64_t_val, svuint64_t_val); + svtblq_mf8(svmfloat8_t_val, svuint8_t_val); + svtblq_s8(svint8_t_val, svuint8_t_val); + svtblq_s16(svint16_t_val, svuint16_t_val); + svtblq_s32(svint32_t_val, svuint32_t_val); + svtblq_s64(svint64_t_val, svuint64_t_val); + svtblq_u8(svuint8_t_val, svuint8_t_val); + svtblq_u16(svuint16_t_val, svuint16_t_val); + svtblq_u32(svuint32_t_val, svuint32_t_val); + svtblq_u64(svuint64_t_val, svuint64_t_val); + svtbxq(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbxq_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq_mf8(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuzpq1(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1(svfloat16_t_val, svfloat16_t_val); + svuzpq1(svfloat32_t_val, svfloat32_t_val); + svuzpq1(svfloat64_t_val, svfloat64_t_val); + svuzpq1(svint8_t_val, svint8_t_val); + svuzpq1(svint16_t_val, svint16_t_val); + svuzpq1(svint32_t_val, svint32_t_val); + svuzpq1(svint64_t_val, svint64_t_val); + svuzpq1(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1(svuint8_t_val, svuint8_t_val); + svuzpq1(svuint16_t_val, svuint16_t_val); + svuzpq1(svuint32_t_val, svuint32_t_val); + svuzpq1(svuint64_t_val, svuint64_t_val); + svuzpq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq1_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq1_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1_s8(svint8_t_val, svint8_t_val); + svuzpq1_s16(svint16_t_val, svint16_t_val); + svuzpq1_s32(svint32_t_val, svint32_t_val); + svuzpq1_s64(svint64_t_val, svint64_t_val); + svuzpq1_u8(svuint8_t_val, svuint8_t_val); + svuzpq1_u16(svuint16_t_val, svuint16_t_val); + svuzpq1_u32(svuint32_t_val, svuint32_t_val); + svuzpq1_u64(svuint64_t_val, svuint64_t_val); + svuzpq2(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2(svfloat16_t_val, svfloat16_t_val); + svuzpq2(svfloat32_t_val, svfloat32_t_val); + svuzpq2(svfloat64_t_val, svfloat64_t_val); + svuzpq2(svint8_t_val, svint8_t_val); + svuzpq2(svint16_t_val, svint16_t_val); + svuzpq2(svint32_t_val, svint32_t_val); + svuzpq2(svint64_t_val, svint64_t_val); + svuzpq2(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2(svuint8_t_val, svuint8_t_val); + svuzpq2(svuint16_t_val, svuint16_t_val); + svuzpq2(svuint32_t_val, svuint32_t_val); + svuzpq2(svuint64_t_val, svuint64_t_val); + svuzpq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq2_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq2_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2_s8(svint8_t_val, svint8_t_val); + svuzpq2_s16(svint16_t_val, svint16_t_val); + svuzpq2_s32(svint32_t_val, svint32_t_val); + svuzpq2_s64(svint64_t_val, svint64_t_val); + svuzpq2_u8(svuint8_t_val, svuint8_t_val); + svuzpq2_u16(svuint16_t_val, svuint16_t_val); + svuzpq2_u32(svuint32_t_val, svuint32_t_val); + svuzpq2_u64(svuint64_t_val, svuint64_t_val); + svzipq1(svbfloat16_t_val, svbfloat16_t_val); + svzipq1(svfloat16_t_val, svfloat16_t_val); + svzipq1(svfloat32_t_val, svfloat32_t_val); + svzipq1(svfloat64_t_val, svfloat64_t_val); + svzipq1(svint8_t_val, svint8_t_val); + svzipq1(svint16_t_val, svint16_t_val); + svzipq1(svint32_t_val, svint32_t_val); + svzipq1(svint64_t_val, svint64_t_val); + svzipq1(svmfloat8_t_val, svmfloat8_t_val); + svzipq1(svuint8_t_val, svuint8_t_val); + svzipq1(svuint16_t_val, svuint16_t_val); + svzipq1(svuint32_t_val, svuint32_t_val); + svzipq1(svuint64_t_val, svuint64_t_val); + svzipq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq1_f16(svfloat16_t_val, svfloat16_t_val); + svzipq1_f32(svfloat32_t_val, svfloat32_t_val); + svzipq1_f64(svfloat64_t_val, svfloat64_t_val); + svzipq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq1_s8(svint8_t_val, svint8_t_val); + svzipq1_s16(svint16_t_val, svint16_t_val); + svzipq1_s32(svint32_t_val, svint32_t_val); + svzipq1_s64(svint64_t_val, svint64_t_val); + svzipq1_u8(svuint8_t_val, svuint8_t_val); + svzipq1_u16(svuint16_t_val, svuint16_t_val); + svzipq1_u32(svuint32_t_val, svuint32_t_val); + svzipq1_u64(svuint64_t_val, svuint64_t_val); + svzipq2(svbfloat16_t_val, svbfloat16_t_val); + svzipq2(svfloat16_t_val, svfloat16_t_val); + svzipq2(svfloat32_t_val, svfloat32_t_val); + svzipq2(svfloat64_t_val, svfloat64_t_val); + svzipq2(svint8_t_val, svint8_t_val); + svzipq2(svint16_t_val, svint16_t_val); + svzipq2(svint32_t_val, svint32_t_val); + svzipq2(svint64_t_val, svint64_t_val); + svzipq2(svmfloat8_t_val, svmfloat8_t_val); + svzipq2(svuint8_t_val, svuint8_t_val); + svzipq2(svuint16_t_val, svuint16_t_val); + svzipq2(svuint32_t_val, svuint32_t_val); + svzipq2(svuint64_t_val, svuint64_t_val); + svzipq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq2_f16(svfloat16_t_val, svfloat16_t_val); + svzipq2_f32(svfloat32_t_val, svfloat32_t_val); + svzipq2_f64(svfloat64_t_val, svfloat64_t_val); + svzipq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq2_s8(svint8_t_val, svint8_t_val); + svzipq2_s16(svint16_t_val, svint16_t_val); + svzipq2_s32(svint32_t_val, svint32_t_val); + svzipq2_s64(svint64_t_val, svint64_t_val); + svzipq2_u8(svuint8_t_val, svuint8_t_val); + svzipq2_u16(svuint16_t_val, svuint16_t_val); + svzipq2_u32(svuint32_t_val, svuint32_t_val); + svzipq2_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svaddqv(svbool_t_val, svfloat16_t_val); + svaddqv(svbool_t_val, svfloat32_t_val); + svaddqv(svbool_t_val, svfloat64_t_val); + svaddqv(svbool_t_val, svint8_t_val); + svaddqv(svbool_t_val, svint16_t_val); + svaddqv(svbool_t_val, svint32_t_val); + svaddqv(svbool_t_val, svint64_t_val); + svaddqv(svbool_t_val, svuint8_t_val); + svaddqv(svbool_t_val, svuint16_t_val); + svaddqv(svbool_t_val, svuint32_t_val); + svaddqv(svbool_t_val, svuint64_t_val); + svaddqv_f16(svbool_t_val, svfloat16_t_val); + svaddqv_f32(svbool_t_val, svfloat32_t_val); + svaddqv_f64(svbool_t_val, svfloat64_t_val); + svaddqv_s8(svbool_t_val, svint8_t_val); + svaddqv_s16(svbool_t_val, svint16_t_val); + svaddqv_s32(svbool_t_val, svint32_t_val); + svaddqv_s64(svbool_t_val, svint64_t_val); + svaddqv_u8(svbool_t_val, svuint8_t_val); + svaddqv_u16(svbool_t_val, svuint16_t_val); + svaddqv_u32(svbool_t_val, svuint32_t_val); + svaddqv_u64(svbool_t_val, svuint64_t_val); + svandqv(svbool_t_val, svint8_t_val); + svandqv(svbool_t_val, svint16_t_val); + svandqv(svbool_t_val, svint32_t_val); + svandqv(svbool_t_val, svint64_t_val); + svandqv(svbool_t_val, svuint8_t_val); + svandqv(svbool_t_val, svuint16_t_val); + svandqv(svbool_t_val, svuint32_t_val); + svandqv(svbool_t_val, svuint64_t_val); + svandqv_s8(svbool_t_val, svint8_t_val); + svandqv_s16(svbool_t_val, svint16_t_val); + svandqv_s32(svbool_t_val, svint32_t_val); + svandqv_s64(svbool_t_val, svint64_t_val); + svandqv_u8(svbool_t_val, svuint8_t_val); + svandqv_u16(svbool_t_val, svuint16_t_val); + svandqv_u32(svbool_t_val, svuint32_t_val); + svandqv_u64(svbool_t_val, svuint64_t_val); + svdup_laneq(svbfloat16_t_val, 2); + svdup_laneq(svfloat16_t_val, 2); + svdup_laneq(svfloat32_t_val, 2); + svdup_laneq(svfloat64_t_val, 1); + svdup_laneq(svint8_t_val, 2); + svdup_laneq(svint16_t_val, 2); + svdup_laneq(svint32_t_val, 2); + svdup_laneq(svint64_t_val, 1); + svdup_laneq(svmfloat8_t_val, 2); + svdup_laneq(svuint8_t_val, 2); + svdup_laneq(svuint16_t_val, 2); + svdup_laneq(svuint32_t_val, 2); + svdup_laneq(svuint64_t_val, 1); + svdup_laneq_bf16(svbfloat16_t_val, 2); + svdup_laneq_f16(svfloat16_t_val, 2); + svdup_laneq_f32(svfloat32_t_val, 2); + svdup_laneq_f64(svfloat64_t_val, 1); + svdup_laneq_mf8(svmfloat8_t_val, 2); + svdup_laneq_s8(svint8_t_val, 2); + svdup_laneq_s16(svint16_t_val, 2); + svdup_laneq_s32(svint32_t_val, 2); + svdup_laneq_s64(svint64_t_val, 1); + svdup_laneq_u8(svuint8_t_val, 2); + svdup_laneq_u16(svuint16_t_val, 2); + svdup_laneq_u32(svuint32_t_val, 2); + svdup_laneq_u64(svuint64_t_val, 1); + sveorqv(svbool_t_val, svint8_t_val); + sveorqv(svbool_t_val, svint16_t_val); + sveorqv(svbool_t_val, svint32_t_val); + sveorqv(svbool_t_val, svint64_t_val); + sveorqv(svbool_t_val, svuint8_t_val); + sveorqv(svbool_t_val, svuint16_t_val); + sveorqv(svbool_t_val, svuint32_t_val); + sveorqv(svbool_t_val, svuint64_t_val); + sveorqv_s8(svbool_t_val, svint8_t_val); + sveorqv_s16(svbool_t_val, svint16_t_val); + sveorqv_s32(svbool_t_val, svint32_t_val); + sveorqv_s64(svbool_t_val, svint64_t_val); + sveorqv_u8(svbool_t_val, svuint8_t_val); + sveorqv_u16(svbool_t_val, svuint16_t_val); + sveorqv_u32(svbool_t_val, svuint32_t_val); + sveorqv_u64(svbool_t_val, svuint64_t_val); + svextq(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq(svfloat16_t_val, svfloat16_t_val, 1); + svextq(svfloat32_t_val, svfloat32_t_val, 1); + svextq(svfloat64_t_val, svfloat64_t_val, 1); + svextq(svint8_t_val, svint8_t_val, 1); + svextq(svint16_t_val, svint16_t_val, 1); + svextq(svint32_t_val, svint32_t_val, 1); + svextq(svint64_t_val, svint64_t_val, 1); + svextq(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq(svuint8_t_val, svuint8_t_val, 1); + svextq(svuint16_t_val, svuint16_t_val, 1); + svextq(svuint32_t_val, svuint32_t_val, 1); + svextq(svuint64_t_val, svuint64_t_val, 1); + svextq_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + svextq_f16(svfloat16_t_val, svfloat16_t_val, 1); + svextq_f32(svfloat32_t_val, svfloat32_t_val, 1); + svextq_f64(svfloat64_t_val, svfloat64_t_val, 1); + svextq_mf8(svmfloat8_t_val, svmfloat8_t_val, 1); + svextq_s8(svint8_t_val, svint8_t_val, 1); + svextq_s16(svint16_t_val, svint16_t_val, 1); + svextq_s32(svint32_t_val, svint32_t_val, 1); + svextq_s64(svint64_t_val, svint64_t_val, 1); + svextq_u8(svuint8_t_val, svuint8_t_val, 1); + svextq_u16(svuint16_t_val, svuint16_t_val, 1); + svextq_u32(svuint32_t_val, svuint32_t_val, 1); + svextq_u64(svuint64_t_val, svuint64_t_val, 1); + svld2q(svbool_t_val, bfloat16_t_ptr_val); + svld2q(svbool_t_val, float16_t_ptr_val); + svld2q(svbool_t_val, float32_t_ptr_val); + svld2q(svbool_t_val, float64_t_ptr_val); + svld2q(svbool_t_val, int8_t_ptr_val); + svld2q(svbool_t_val, int16_t_ptr_val); + svld2q(svbool_t_val, int32_t_ptr_val); + svld2q(svbool_t_val, int64_t_ptr_val); + svld2q(svbool_t_val, mfloat8_t_ptr_val); + svld2q(svbool_t_val, uint8_t_ptr_val); + svld2q(svbool_t_val, uint16_t_ptr_val); + svld2q(svbool_t_val, uint32_t_ptr_val); + svld2q(svbool_t_val, uint64_t_ptr_val); + svld2q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2q_f16(svbool_t_val, float16_t_ptr_val); + svld2q_f32(svbool_t_val, float32_t_ptr_val); + svld2q_f64(svbool_t_val, float64_t_ptr_val); + svld2q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2q_s8(svbool_t_val, int8_t_ptr_val); + svld2q_s16(svbool_t_val, int16_t_ptr_val); + svld2q_s32(svbool_t_val, int32_t_ptr_val); + svld2q_s64(svbool_t_val, int64_t_ptr_val); + svld2q_u8(svbool_t_val, uint8_t_ptr_val); + svld2q_u16(svbool_t_val, uint16_t_ptr_val); + svld2q_u32(svbool_t_val, uint32_t_ptr_val); + svld2q_u64(svbool_t_val, uint64_t_ptr_val); + svld2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q(svbool_t_val, bfloat16_t_ptr_val); + svld3q(svbool_t_val, float16_t_ptr_val); + svld3q(svbool_t_val, float32_t_ptr_val); + svld3q(svbool_t_val, float64_t_ptr_val); + svld3q(svbool_t_val, int8_t_ptr_val); + svld3q(svbool_t_val, int16_t_ptr_val); + svld3q(svbool_t_val, int32_t_ptr_val); + svld3q(svbool_t_val, int64_t_ptr_val); + svld3q(svbool_t_val, mfloat8_t_ptr_val); + svld3q(svbool_t_val, uint8_t_ptr_val); + svld3q(svbool_t_val, uint16_t_ptr_val); + svld3q(svbool_t_val, uint32_t_ptr_val); + svld3q(svbool_t_val, uint64_t_ptr_val); + svld3q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3q_f16(svbool_t_val, float16_t_ptr_val); + svld3q_f32(svbool_t_val, float32_t_ptr_val); + svld3q_f64(svbool_t_val, float64_t_ptr_val); + svld3q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3q_s8(svbool_t_val, int8_t_ptr_val); + svld3q_s16(svbool_t_val, int16_t_ptr_val); + svld3q_s32(svbool_t_val, int32_t_ptr_val); + svld3q_s64(svbool_t_val, int64_t_ptr_val); + svld3q_u8(svbool_t_val, uint8_t_ptr_val); + svld3q_u16(svbool_t_val, uint16_t_ptr_val); + svld3q_u32(svbool_t_val, uint32_t_ptr_val); + svld3q_u64(svbool_t_val, uint64_t_ptr_val); + svld3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q(svbool_t_val, bfloat16_t_ptr_val); + svld4q(svbool_t_val, float16_t_ptr_val); + svld4q(svbool_t_val, float32_t_ptr_val); + svld4q(svbool_t_val, float64_t_ptr_val); + svld4q(svbool_t_val, int8_t_ptr_val); + svld4q(svbool_t_val, int16_t_ptr_val); + svld4q(svbool_t_val, int32_t_ptr_val); + svld4q(svbool_t_val, int64_t_ptr_val); + svld4q(svbool_t_val, mfloat8_t_ptr_val); + svld4q(svbool_t_val, uint8_t_ptr_val); + svld4q(svbool_t_val, uint16_t_ptr_val); + svld4q(svbool_t_val, uint32_t_ptr_val); + svld4q(svbool_t_val, uint64_t_ptr_val); + svld4q_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4q_f16(svbool_t_val, float16_t_ptr_val); + svld4q_f32(svbool_t_val, float32_t_ptr_val); + svld4q_f64(svbool_t_val, float64_t_ptr_val); + svld4q_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4q_s8(svbool_t_val, int8_t_ptr_val); + svld4q_s16(svbool_t_val, int16_t_ptr_val); + svld4q_s32(svbool_t_val, int32_t_ptr_val); + svld4q_s64(svbool_t_val, int64_t_ptr_val); + svld4q_u8(svbool_t_val, uint8_t_ptr_val); + svld4q_u16(svbool_t_val, uint16_t_ptr_val); + svld4q_u32(svbool_t_val, uint32_t_ptr_val); + svld4q_u64(svbool_t_val, uint64_t_ptr_val); + svld4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svmaxnmqv(svbool_t_val, svfloat16_t_val); + svmaxnmqv(svbool_t_val, svfloat32_t_val); + svmaxnmqv(svbool_t_val, svfloat64_t_val); + svmaxnmqv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmqv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svfloat16_t_val); + svmaxqv(svbool_t_val, svfloat32_t_val); + svmaxqv(svbool_t_val, svfloat64_t_val); + svmaxqv(svbool_t_val, svint8_t_val); + svmaxqv(svbool_t_val, svint16_t_val); + svmaxqv(svbool_t_val, svint32_t_val); + svmaxqv(svbool_t_val, svint64_t_val); + svmaxqv(svbool_t_val, svuint8_t_val); + svmaxqv(svbool_t_val, svuint16_t_val); + svmaxqv(svbool_t_val, svuint32_t_val); + svmaxqv(svbool_t_val, svuint64_t_val); + svmaxqv_f16(svbool_t_val, svfloat16_t_val); + svmaxqv_f32(svbool_t_val, svfloat32_t_val); + svmaxqv_f64(svbool_t_val, svfloat64_t_val); + svmaxqv_s8(svbool_t_val, svint8_t_val); + svmaxqv_s16(svbool_t_val, svint16_t_val); + svmaxqv_s32(svbool_t_val, svint32_t_val); + svmaxqv_s64(svbool_t_val, svint64_t_val); + svmaxqv_u8(svbool_t_val, svuint8_t_val); + svmaxqv_u16(svbool_t_val, svuint16_t_val); + svmaxqv_u32(svbool_t_val, svuint32_t_val); + svmaxqv_u64(svbool_t_val, svuint64_t_val); + svminnmqv(svbool_t_val, svfloat16_t_val); + svminnmqv(svbool_t_val, svfloat32_t_val); + svminnmqv(svbool_t_val, svfloat64_t_val); + svminnmqv_f16(svbool_t_val, svfloat16_t_val); + svminnmqv_f32(svbool_t_val, svfloat32_t_val); + svminnmqv_f64(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svfloat16_t_val); + svminqv(svbool_t_val, svfloat32_t_val); + svminqv(svbool_t_val, svfloat64_t_val); + svminqv(svbool_t_val, svint8_t_val); + svminqv(svbool_t_val, svint16_t_val); + svminqv(svbool_t_val, svint32_t_val); + svminqv(svbool_t_val, svint64_t_val); + svminqv(svbool_t_val, svuint8_t_val); + svminqv(svbool_t_val, svuint16_t_val); + svminqv(svbool_t_val, svuint32_t_val); + svminqv(svbool_t_val, svuint64_t_val); + svminqv_f16(svbool_t_val, svfloat16_t_val); + svminqv_f32(svbool_t_val, svfloat32_t_val); + svminqv_f64(svbool_t_val, svfloat64_t_val); + svminqv_s8(svbool_t_val, svint8_t_val); + svminqv_s16(svbool_t_val, svint16_t_val); + svminqv_s32(svbool_t_val, svint32_t_val); + svminqv_s64(svbool_t_val, svint64_t_val); + svminqv_u8(svbool_t_val, svuint8_t_val); + svminqv_u16(svbool_t_val, svuint16_t_val); + svminqv_u32(svbool_t_val, svuint32_t_val); + svminqv_u64(svbool_t_val, svuint64_t_val); + svorqv(svbool_t_val, svint8_t_val); + svorqv(svbool_t_val, svint16_t_val); + svorqv(svbool_t_val, svint32_t_val); + svorqv(svbool_t_val, svint64_t_val); + svorqv(svbool_t_val, svuint8_t_val); + svorqv(svbool_t_val, svuint16_t_val); + svorqv(svbool_t_val, svuint32_t_val); + svorqv(svbool_t_val, svuint64_t_val); + svorqv_s8(svbool_t_val, svint8_t_val); + svorqv_s16(svbool_t_val, svint16_t_val); + svorqv_s32(svbool_t_val, svint32_t_val); + svorqv_s64(svbool_t_val, svint64_t_val); + svorqv_u8(svbool_t_val, svuint8_t_val); + svorqv_u16(svbool_t_val, svuint16_t_val); + svorqv_u32(svbool_t_val, svuint32_t_val); + svorqv_u64(svbool_t_val, svuint64_t_val); + svpmov(svint8_t_val); + svpmov(svint16_t_val); + svpmov(svint32_t_val); + svpmov(svint64_t_val); + svpmov(svuint8_t_val); + svpmov(svuint16_t_val); + svpmov(svuint32_t_val); + svpmov(svuint64_t_val); + svpmov_lane(svint8_t_val, 0); + svpmov_lane(svint16_t_val, 1); + svpmov_lane(svint32_t_val, 2); + svpmov_lane(svint64_t_val, 2); + svpmov_lane(svuint8_t_val, 0); + svpmov_lane(svuint16_t_val, 1); + svpmov_lane(svuint32_t_val, 2); + svpmov_lane(svuint64_t_val, 2); + svpmov_lane_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_m(svuint64_t_val, svbool_t_val, 2); + svpmov_lane_s8(svint8_t_val, 0); + svpmov_lane_s16(svint16_t_val, 1); + svpmov_lane_s16_m(svint16_t_val, svbool_t_val, 1); + svpmov_lane_s32(svint32_t_val, 2); + svpmov_lane_s32_m(svint32_t_val, svbool_t_val, 2); + svpmov_lane_s64(svint64_t_val, 2); + svpmov_lane_s64_m(svint64_t_val, svbool_t_val, 2); + svpmov_lane_u8(svuint8_t_val, 0); + svpmov_lane_u16(svuint16_t_val, 1); + svpmov_lane_u16_m(svuint16_t_val, svbool_t_val, 1); + svpmov_lane_u32(svuint32_t_val, 2); + svpmov_lane_u32_m(svuint32_t_val, svbool_t_val, 2); + svpmov_lane_u64(svuint64_t_val, 2); + svpmov_lane_u64_m(svuint64_t_val, svbool_t_val, 2); + svpmov_s8(svint8_t_val); + svpmov_s8_z(svbool_t_val); + svpmov_s16(svint16_t_val); + svpmov_s16_z(svbool_t_val); + svpmov_s32(svint32_t_val); + svpmov_s32_z(svbool_t_val); + svpmov_s64(svint64_t_val); + svpmov_s64_z(svbool_t_val); + svpmov_u8(svuint8_t_val); + svpmov_u8_z(svbool_t_val); + svpmov_u16(svuint16_t_val); + svpmov_u16_z(svbool_t_val); + svpmov_u32(svuint32_t_val); + svpmov_u32_z(svbool_t_val); + svpmov_u64(svuint64_t_val); + svpmov_u64_z(svbool_t_val); + svst2q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2q_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2q_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2q_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2q_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3q_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3q_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3q_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3q_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4q(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4q_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4q_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4q_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4q_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4q_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4q_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4q_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4q_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4q_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4q_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4q_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4q_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4q_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4q_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4q_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4q_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4q_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4q_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4q_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4q_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4q_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4q_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4q_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4q_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4q_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4q_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svtblq(svbfloat16_t_val, svuint16_t_val); + svtblq(svfloat16_t_val, svuint16_t_val); + svtblq(svfloat32_t_val, svuint32_t_val); + svtblq(svfloat64_t_val, svuint64_t_val); + svtblq(svint8_t_val, svuint8_t_val); + svtblq(svint16_t_val, svuint16_t_val); + svtblq(svint32_t_val, svuint32_t_val); + svtblq(svint64_t_val, svuint64_t_val); + svtblq(svmfloat8_t_val, svuint8_t_val); + svtblq(svuint8_t_val, svuint8_t_val); + svtblq(svuint16_t_val, svuint16_t_val); + svtblq(svuint32_t_val, svuint32_t_val); + svtblq(svuint64_t_val, svuint64_t_val); + svtblq_bf16(svbfloat16_t_val, svuint16_t_val); + svtblq_f16(svfloat16_t_val, svuint16_t_val); + svtblq_f32(svfloat32_t_val, svuint32_t_val); + svtblq_f64(svfloat64_t_val, svuint64_t_val); + svtblq_mf8(svmfloat8_t_val, svuint8_t_val); + svtblq_s8(svint8_t_val, svuint8_t_val); + svtblq_s16(svint16_t_val, svuint16_t_val); + svtblq_s32(svint32_t_val, svuint32_t_val); + svtblq_s64(svint64_t_val, svuint64_t_val); + svtblq_u8(svuint8_t_val, svuint8_t_val); + svtblq_u16(svuint16_t_val, svuint16_t_val); + svtblq_u32(svuint32_t_val, svuint32_t_val); + svtblq_u64(svuint64_t_val, svuint64_t_val); + svtbxq(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbxq_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbxq_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbxq_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbxq_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbxq_mf8(svmfloat8_t_val, svmfloat8_t_val, svuint8_t_val); + svtbxq_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbxq_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbxq_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbxq_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbxq_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbxq_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbxq_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbxq_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuzpq1(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1(svfloat16_t_val, svfloat16_t_val); + svuzpq1(svfloat32_t_val, svfloat32_t_val); + svuzpq1(svfloat64_t_val, svfloat64_t_val); + svuzpq1(svint8_t_val, svint8_t_val); + svuzpq1(svint16_t_val, svint16_t_val); + svuzpq1(svint32_t_val, svint32_t_val); + svuzpq1(svint64_t_val, svint64_t_val); + svuzpq1(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1(svuint8_t_val, svuint8_t_val); + svuzpq1(svuint16_t_val, svuint16_t_val); + svuzpq1(svuint32_t_val, svuint32_t_val); + svuzpq1(svuint64_t_val, svuint64_t_val); + svuzpq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq1_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq1_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq1_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq1_s8(svint8_t_val, svint8_t_val); + svuzpq1_s16(svint16_t_val, svint16_t_val); + svuzpq1_s32(svint32_t_val, svint32_t_val); + svuzpq1_s64(svint64_t_val, svint64_t_val); + svuzpq1_u8(svuint8_t_val, svuint8_t_val); + svuzpq1_u16(svuint16_t_val, svuint16_t_val); + svuzpq1_u32(svuint32_t_val, svuint32_t_val); + svuzpq1_u64(svuint64_t_val, svuint64_t_val); + svuzpq2(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2(svfloat16_t_val, svfloat16_t_val); + svuzpq2(svfloat32_t_val, svfloat32_t_val); + svuzpq2(svfloat64_t_val, svfloat64_t_val); + svuzpq2(svint8_t_val, svint8_t_val); + svuzpq2(svint16_t_val, svint16_t_val); + svuzpq2(svint32_t_val, svint32_t_val); + svuzpq2(svint64_t_val, svint64_t_val); + svuzpq2(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2(svuint8_t_val, svuint8_t_val); + svuzpq2(svuint16_t_val, svuint16_t_val); + svuzpq2(svuint32_t_val, svuint32_t_val); + svuzpq2(svuint64_t_val, svuint64_t_val); + svuzpq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzpq2_f16(svfloat16_t_val, svfloat16_t_val); + svuzpq2_f32(svfloat32_t_val, svfloat32_t_val); + svuzpq2_f64(svfloat64_t_val, svfloat64_t_val); + svuzpq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svuzpq2_s8(svint8_t_val, svint8_t_val); + svuzpq2_s16(svint16_t_val, svint16_t_val); + svuzpq2_s32(svint32_t_val, svint32_t_val); + svuzpq2_s64(svint64_t_val, svint64_t_val); + svuzpq2_u8(svuint8_t_val, svuint8_t_val); + svuzpq2_u16(svuint16_t_val, svuint16_t_val); + svuzpq2_u32(svuint32_t_val, svuint32_t_val); + svuzpq2_u64(svuint64_t_val, svuint64_t_val); + svzipq1(svbfloat16_t_val, svbfloat16_t_val); + svzipq1(svfloat16_t_val, svfloat16_t_val); + svzipq1(svfloat32_t_val, svfloat32_t_val); + svzipq1(svfloat64_t_val, svfloat64_t_val); + svzipq1(svint8_t_val, svint8_t_val); + svzipq1(svint16_t_val, svint16_t_val); + svzipq1(svint32_t_val, svint32_t_val); + svzipq1(svint64_t_val, svint64_t_val); + svzipq1(svmfloat8_t_val, svmfloat8_t_val); + svzipq1(svuint8_t_val, svuint8_t_val); + svzipq1(svuint16_t_val, svuint16_t_val); + svzipq1(svuint32_t_val, svuint32_t_val); + svzipq1(svuint64_t_val, svuint64_t_val); + svzipq1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq1_f16(svfloat16_t_val, svfloat16_t_val); + svzipq1_f32(svfloat32_t_val, svfloat32_t_val); + svzipq1_f64(svfloat64_t_val, svfloat64_t_val); + svzipq1_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq1_s8(svint8_t_val, svint8_t_val); + svzipq1_s16(svint16_t_val, svint16_t_val); + svzipq1_s32(svint32_t_val, svint32_t_val); + svzipq1_s64(svint64_t_val, svint64_t_val); + svzipq1_u8(svuint8_t_val, svuint8_t_val); + svzipq1_u16(svuint16_t_val, svuint16_t_val); + svzipq1_u32(svuint32_t_val, svuint32_t_val); + svzipq1_u64(svuint64_t_val, svuint64_t_val); + svzipq2(svbfloat16_t_val, svbfloat16_t_val); + svzipq2(svfloat16_t_val, svfloat16_t_val); + svzipq2(svfloat32_t_val, svfloat32_t_val); + svzipq2(svfloat64_t_val, svfloat64_t_val); + svzipq2(svint8_t_val, svint8_t_val); + svzipq2(svint16_t_val, svint16_t_val); + svzipq2(svint32_t_val, svint32_t_val); + svzipq2(svint64_t_val, svint64_t_val); + svzipq2(svmfloat8_t_val, svmfloat8_t_val); + svzipq2(svuint8_t_val, svuint8_t_val); + svzipq2(svuint16_t_val, svuint16_t_val); + svzipq2(svuint32_t_val, svuint32_t_val); + svzipq2(svuint64_t_val, svuint64_t_val); + svzipq2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzipq2_f16(svfloat16_t_val, svfloat16_t_val); + svzipq2_f32(svfloat32_t_val, svfloat32_t_val); + svzipq2_f64(svfloat64_t_val, svfloat64_t_val); + svzipq2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svzipq2_s8(svint8_t_val, svint8_t_val); + svzipq2_s16(svint16_t_val, svint16_t_val); + svzipq2_s32(svint32_t_val, svint32_t_val); + svzipq2_s64(svint64_t_val, svint64_t_val); + svzipq2_u8(svuint8_t_val, svuint8_t_val); + svzipq2_u16(svuint16_t_val, svuint16_t_val); + svzipq2_u32(svuint32_t_val, svuint32_t_val); + svzipq2_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme_RP___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme_RP___sme.c new file mode 100644 index 0000000..5543a3b --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2p1_OR_sme_RP___sme.c @@ -0,0 +1,360 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,(sve2p1|sme)" streaming_guard="sme" flags="feature-dependent" + +void test(void) { + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + + svclamp(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svclamp_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpsel_lane_b8(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b16(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b32(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b64(svbool_t_val, svbool_t_val, uint32_t_val); + svrevd_bf16_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_bf16_x(svbool_t_val, svbfloat16_t_val); + svrevd_bf16_z(svbool_t_val, svbfloat16_t_val); + svrevd_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_f16_x(svbool_t_val, svfloat16_t_val); + svrevd_f16_z(svbool_t_val, svfloat16_t_val); + svrevd_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_f32_x(svbool_t_val, svfloat32_t_val); + svrevd_f32_z(svbool_t_val, svfloat32_t_val); + svrevd_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_f64_x(svbool_t_val, svfloat64_t_val); + svrevd_f64_z(svbool_t_val, svfloat64_t_val); + svrevd_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_mf8_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_mf8_x(svbool_t_val, svmfloat8_t_val); + svrevd_mf8_z(svbool_t_val, svmfloat8_t_val); + svrevd_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_s8_x(svbool_t_val, svint8_t_val); + svrevd_s8_z(svbool_t_val, svint8_t_val); + svrevd_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_s16_x(svbool_t_val, svint16_t_val); + svrevd_s16_z(svbool_t_val, svint16_t_val); + svrevd_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_s32_x(svbool_t_val, svint32_t_val); + svrevd_s32_z(svbool_t_val, svint32_t_val); + svrevd_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_s64_x(svbool_t_val, svint64_t_val); + svrevd_s64_z(svbool_t_val, svint64_t_val); + svrevd_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_u8_x(svbool_t_val, svuint8_t_val); + svrevd_u8_z(svbool_t_val, svuint8_t_val); + svrevd_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_u16_x(svbool_t_val, svuint16_t_val); + svrevd_u16_z(svbool_t_val, svuint16_t_val); + svrevd_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_u32_x(svbool_t_val, svuint32_t_val); + svrevd_u32_z(svbool_t_val, svuint32_t_val); + svrevd_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_u64_x(svbool_t_val, svuint64_t_val); + svrevd_u64_z(svbool_t_val, svuint64_t_val); + svrevd_x(svbool_t_val, svbfloat16_t_val); + svrevd_x(svbool_t_val, svfloat16_t_val); + svrevd_x(svbool_t_val, svfloat32_t_val); + svrevd_x(svbool_t_val, svfloat64_t_val); + svrevd_x(svbool_t_val, svint8_t_val); + svrevd_x(svbool_t_val, svint16_t_val); + svrevd_x(svbool_t_val, svint32_t_val); + svrevd_x(svbool_t_val, svint64_t_val); + svrevd_x(svbool_t_val, svmfloat8_t_val); + svrevd_x(svbool_t_val, svuint8_t_val); + svrevd_x(svbool_t_val, svuint16_t_val); + svrevd_x(svbool_t_val, svuint32_t_val); + svrevd_x(svbool_t_val, svuint64_t_val); + svrevd_z(svbool_t_val, svbfloat16_t_val); + svrevd_z(svbool_t_val, svfloat16_t_val); + svrevd_z(svbool_t_val, svfloat32_t_val); + svrevd_z(svbool_t_val, svfloat64_t_val); + svrevd_z(svbool_t_val, svint8_t_val); + svrevd_z(svbool_t_val, svint16_t_val); + svrevd_z(svbool_t_val, svint32_t_val); + svrevd_z(svbool_t_val, svint64_t_val); + svrevd_z(svbool_t_val, svmfloat8_t_val); + svrevd_z(svbool_t_val, svuint8_t_val); + svrevd_z(svbool_t_val, svuint16_t_val); + svrevd_z(svbool_t_val, svuint32_t_val); + svrevd_z(svbool_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + + svclamp(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svclamp_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpsel_lane_b8(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b16(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b32(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b64(svbool_t_val, svbool_t_val, uint32_t_val); + svrevd_bf16_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_bf16_x(svbool_t_val, svbfloat16_t_val); + svrevd_bf16_z(svbool_t_val, svbfloat16_t_val); + svrevd_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_f16_x(svbool_t_val, svfloat16_t_val); + svrevd_f16_z(svbool_t_val, svfloat16_t_val); + svrevd_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_f32_x(svbool_t_val, svfloat32_t_val); + svrevd_f32_z(svbool_t_val, svfloat32_t_val); + svrevd_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_f64_x(svbool_t_val, svfloat64_t_val); + svrevd_f64_z(svbool_t_val, svfloat64_t_val); + svrevd_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_mf8_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_mf8_x(svbool_t_val, svmfloat8_t_val); + svrevd_mf8_z(svbool_t_val, svmfloat8_t_val); + svrevd_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_s8_x(svbool_t_val, svint8_t_val); + svrevd_s8_z(svbool_t_val, svint8_t_val); + svrevd_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_s16_x(svbool_t_val, svint16_t_val); + svrevd_s16_z(svbool_t_val, svint16_t_val); + svrevd_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_s32_x(svbool_t_val, svint32_t_val); + svrevd_s32_z(svbool_t_val, svint32_t_val); + svrevd_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_s64_x(svbool_t_val, svint64_t_val); + svrevd_s64_z(svbool_t_val, svint64_t_val); + svrevd_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_u8_x(svbool_t_val, svuint8_t_val); + svrevd_u8_z(svbool_t_val, svuint8_t_val); + svrevd_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_u16_x(svbool_t_val, svuint16_t_val); + svrevd_u16_z(svbool_t_val, svuint16_t_val); + svrevd_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_u32_x(svbool_t_val, svuint32_t_val); + svrevd_u32_z(svbool_t_val, svuint32_t_val); + svrevd_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_u64_x(svbool_t_val, svuint64_t_val); + svrevd_u64_z(svbool_t_val, svuint64_t_val); + svrevd_x(svbool_t_val, svbfloat16_t_val); + svrevd_x(svbool_t_val, svfloat16_t_val); + svrevd_x(svbool_t_val, svfloat32_t_val); + svrevd_x(svbool_t_val, svfloat64_t_val); + svrevd_x(svbool_t_val, svint8_t_val); + svrevd_x(svbool_t_val, svint16_t_val); + svrevd_x(svbool_t_val, svint32_t_val); + svrevd_x(svbool_t_val, svint64_t_val); + svrevd_x(svbool_t_val, svmfloat8_t_val); + svrevd_x(svbool_t_val, svuint8_t_val); + svrevd_x(svbool_t_val, svuint16_t_val); + svrevd_x(svbool_t_val, svuint32_t_val); + svrevd_x(svbool_t_val, svuint64_t_val); + svrevd_z(svbool_t_val, svbfloat16_t_val); + svrevd_z(svbool_t_val, svfloat16_t_val); + svrevd_z(svbool_t_val, svfloat32_t_val); + svrevd_z(svbool_t_val, svfloat64_t_val); + svrevd_z(svbool_t_val, svint8_t_val); + svrevd_z(svbool_t_val, svint16_t_val); + svrevd_z(svbool_t_val, svint32_t_val); + svrevd_z(svbool_t_val, svint64_t_val); + svrevd_z(svbool_t_val, svmfloat8_t_val); + svrevd_z(svbool_t_val, svuint8_t_val); + svrevd_z(svbool_t_val, svuint16_t_val); + svrevd_z(svbool_t_val, svuint32_t_val); + svrevd_z(svbool_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint32_t uint32_t_val; + + svclamp(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svclamp_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svclamp_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svclamp_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svclamp_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svclamp_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svclamp_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svclamp_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svclamp_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpsel_lane_b8(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b16(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b32(svbool_t_val, svbool_t_val, uint32_t_val); + svpsel_lane_b64(svbool_t_val, svbool_t_val, uint32_t_val); + svrevd_bf16_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_bf16_x(svbool_t_val, svbfloat16_t_val); + svrevd_bf16_z(svbool_t_val, svbfloat16_t_val); + svrevd_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_f16_x(svbool_t_val, svfloat16_t_val); + svrevd_f16_z(svbool_t_val, svfloat16_t_val); + svrevd_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_f32_x(svbool_t_val, svfloat32_t_val); + svrevd_f32_z(svbool_t_val, svfloat32_t_val); + svrevd_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_f64_x(svbool_t_val, svfloat64_t_val); + svrevd_f64_z(svbool_t_val, svfloat64_t_val); + svrevd_m(svbfloat16_t_val, svbool_t_val, svbfloat16_t_val); + svrevd_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrevd_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrevd_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrevd_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_mf8_m(svmfloat8_t_val, svbool_t_val, svmfloat8_t_val); + svrevd_mf8_x(svbool_t_val, svmfloat8_t_val); + svrevd_mf8_z(svbool_t_val, svmfloat8_t_val); + svrevd_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrevd_s8_x(svbool_t_val, svint8_t_val); + svrevd_s8_z(svbool_t_val, svint8_t_val); + svrevd_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevd_s16_x(svbool_t_val, svint16_t_val); + svrevd_s16_z(svbool_t_val, svint16_t_val); + svrevd_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevd_s32_x(svbool_t_val, svint32_t_val); + svrevd_s32_z(svbool_t_val, svint32_t_val); + svrevd_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevd_s64_x(svbool_t_val, svint64_t_val); + svrevd_s64_z(svbool_t_val, svint64_t_val); + svrevd_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrevd_u8_x(svbool_t_val, svuint8_t_val); + svrevd_u8_z(svbool_t_val, svuint8_t_val); + svrevd_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevd_u16_x(svbool_t_val, svuint16_t_val); + svrevd_u16_z(svbool_t_val, svuint16_t_val); + svrevd_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevd_u32_x(svbool_t_val, svuint32_t_val); + svrevd_u32_z(svbool_t_val, svuint32_t_val); + svrevd_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevd_u64_x(svbool_t_val, svuint64_t_val); + svrevd_u64_z(svbool_t_val, svuint64_t_val); + svrevd_x(svbool_t_val, svbfloat16_t_val); + svrevd_x(svbool_t_val, svfloat16_t_val); + svrevd_x(svbool_t_val, svfloat32_t_val); + svrevd_x(svbool_t_val, svfloat64_t_val); + svrevd_x(svbool_t_val, svint8_t_val); + svrevd_x(svbool_t_val, svint16_t_val); + svrevd_x(svbool_t_val, svint32_t_val); + svrevd_x(svbool_t_val, svint64_t_val); + svrevd_x(svbool_t_val, svmfloat8_t_val); + svrevd_x(svbool_t_val, svuint8_t_val); + svrevd_x(svbool_t_val, svuint16_t_val); + svrevd_x(svbool_t_val, svuint32_t_val); + svrevd_x(svbool_t_val, svuint64_t_val); + svrevd_z(svbool_t_val, svbfloat16_t_val); + svrevd_z(svbool_t_val, svfloat16_t_val); + svrevd_z(svbool_t_val, svfloat32_t_val); + svrevd_z(svbool_t_val, svfloat64_t_val); + svrevd_z(svbool_t_val, svint8_t_val); + svrevd_z(svbool_t_val, svint16_t_val); + svrevd_z(svbool_t_val, svint32_t_val); + svrevd_z(svbool_t_val, svint64_t_val); + svrevd_z(svbool_t_val, svmfloat8_t_val); + svrevd_z(svbool_t_val, svuint8_t_val); + svrevd_z(svbool_t_val, svuint16_t_val); + svrevd_z(svbool_t_val, svuint32_t_val); + svrevd_z(svbool_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_bf16___sme_AND_bf16.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_bf16___sme_AND_bf16.c new file mode 100644 index 0000000..eb4787d --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_bf16___sme_AND_bf16.c @@ -0,0 +1,111 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +bf16 -target-feature +sme -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,bf16" streaming_guard="sme,bf16" flags="feature-dependent" + +void test(void) { + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + + svbfdot(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfdot(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svcvt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_z(svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + + svbfdot(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfdot(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svcvt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_z(svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + + svbfdot(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfdot(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfdot_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfdot_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalb(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalb_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalb_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svbfmlalt(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmlalt_lane(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_lane_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val, 2); + svbfmlalt_n_f32(svfloat32_t_val, svbfloat16_t_val, bfloat16_t_val); + svcvt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_bf16_x(svbool_t_val, svfloat32_t_val); + svcvt_bf16_z(svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_f32_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_bf16_m(svbfloat16_t_val, svbool_t_val, svfloat32_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_i8mm___sme_AND_i8mm.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_i8mm___sme_AND_i8mm.c new file mode 100644 index 0000000..cd86050 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_i8mm___sme_AND_i8mm.c @@ -0,0 +1,72 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +i8mm -target-feature +sme -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,i8mm" streaming_guard="sme,i8mm" flags="feature-dependent" + +void test(void) { + int8_t int8_t_val; + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + uint8_t uint8_t_val; + + svsudot(svint32_t_val, svint8_t_val, svuint8_t_val); + svsudot(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_lane(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_lane_s32(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_n_s32(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_s32(svint32_t_val, svint8_t_val, svuint8_t_val); + svusdot(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot(svint32_t_val, svuint8_t_val, svint8_t_val); + svusdot_lane(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_lane_s32(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_n_s32(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} + +void test_streaming(void) __arm_streaming{ + int8_t int8_t_val; + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + uint8_t uint8_t_val; + + svsudot(svint32_t_val, svint8_t_val, svuint8_t_val); + svsudot(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_lane(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_lane_s32(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_n_s32(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_s32(svint32_t_val, svint8_t_val, svuint8_t_val); + svusdot(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot(svint32_t_val, svuint8_t_val, svint8_t_val); + svusdot_lane(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_lane_s32(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_n_s32(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + int8_t int8_t_val; + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + uint8_t uint8_t_val; + + svsudot(svint32_t_val, svint8_t_val, svuint8_t_val); + svsudot(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_lane(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_lane_s32(svint32_t_val, svint8_t_val, svuint8_t_val, 1); + svsudot_n_s32(svint32_t_val, svint8_t_val, uint8_t_val); + svsudot_s32(svint32_t_val, svint8_t_val, svuint8_t_val); + svusdot(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot(svint32_t_val, svuint8_t_val, svint8_t_val); + svusdot_lane(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_lane_s32(svint32_t_val, svuint8_t_val, svint8_t_val, 1); + svusdot_n_s32(svint32_t_val, svuint8_t_val, int8_t_val); + svusdot_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-aes___sme_AND_ssve-aes.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-aes___sme_AND_ssve-aes.c new file mode 100644 index 0000000..c42481a --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-aes___sme_AND_ssve-aes.c @@ -0,0 +1,144 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve-aes -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-aes -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-aes -target-feature +sve -target-feature +sve-aes -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve-aes" streaming_guard="sme,ssve-aes" flags="feature-dependent" + +void test(void) { + svuint8_t svuint8_t_val; + svuint64_t svuint64_t_val; + uint64_t uint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesd(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesd_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaese(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaese_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesimc(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesimc_u8(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesmc(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesmc_u8(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svuint8_t svuint8_t_val; + svuint64_t svuint64_t_val; + uint64_t uint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesd(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesd_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaese(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaese_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesimc(svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesimc_u8(svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesmc(svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svaesmc_u8(svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullb_pair(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullb_pair(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullb_pair_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullb_pair_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullt_pair(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullt_pair(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullt_pair_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpmullt_pair_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svuint8_t svuint8_t_val; + svuint64_t svuint64_t_val; + uint64_t uint64_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesd(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesd_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaese(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaese_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesimc(svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesimc_u8(svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesmc(svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaesmc_u8(svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-b16b16___sme_AND_sme2_AND_sve-b16b16.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-b16b16___sme_AND_sme2_AND_sve-b16b16.c new file mode 100644 index 0000000..887c7d2 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-b16b16___sme_AND_sme2_AND_sve-b16b16.c @@ -0,0 +1,611 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve-b16b16 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve-b16b16 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve-b16b16" streaming_guard="sme,sme2,sve-b16b16" flags="feature-dependent" + +void test(void) { + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + + svadd_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svadd_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svadd_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svadd_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svadd_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svadd_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svadd_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclamp(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclamp_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmax_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmaxnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmaxnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmin_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmin_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svminnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svminnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + svmla_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + svmls_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_lane(svbfloat16_t_val, svbfloat16_t_val, 1); + svmul_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + svmul_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmul_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svmul_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsub_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + svsub_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svclamp(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svclamp_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_lane(svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t bfloat16_t_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadd_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svclamp(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svclamp_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmax_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmaxnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmin_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svminnm_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmla_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_lane(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_n_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmls_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_lane(svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_lane_bf16(svbfloat16_t_val, svbfloat16_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmul_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_bf16_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_m(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_m(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_n_bf16_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_x(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_x(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_z(svbool_t_val, svbfloat16_t_val, bfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsub_z(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-bitperm___sme_AND_ssve-bitperm.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-bitperm___sme_AND_ssve-bitperm.c new file mode 100644 index 0000000..b4c8733 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-bitperm___sme_AND_ssve-bitperm.c @@ -0,0 +1,383 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve-bitperm -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-bitperm -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-bitperm -target-feature +sve -target-feature +sve-bitperm -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve-bitperm" streaming_guard="sme,ssve-bitperm" flags="feature-dependent" + +void test(void) { + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t uint8_t_val; + uint16_t uint16_t_val; + uint32_t uint32_t_val; + uint64_t uint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t uint8_t_val; + uint16_t uint16_t_val; + uint32_t uint32_t_val; + uint64_t uint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbdep_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbext_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbgrp_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t uint8_t_val; + uint16_t uint16_t_val; + uint32_t uint32_t_val; + uint64_t uint64_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbdep_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbext_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint64_t_val, svuint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u8(svuint8_t_val, uint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u16(svuint16_t_val, uint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u32(svuint32_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_n_u64(svuint64_t_val, uint64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbgrp_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sve-sha3_AND_sme2p1.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sve-sha3_AND_sme2p1.c new file mode 100644 index 0000000..7e4a06f --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve-sha3___sme_AND_sve-sha3_AND_sme2p1.c @@ -0,0 +1,48 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve-sha3 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2p1 -target-feature +sve -target-feature +sve-sha3 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve-sha3" streaming_guard="sme,sve-sha3,sme2p1" flags="feature-dependent" + +void test(void) { + svint64_t svint64_t_val; + svuint64_t svuint64_t_val; + + svrax1(svint64_t_val, svint64_t_val); + svrax1(svuint64_t_val, svuint64_t_val); + svrax1_s64(svint64_t_val, svint64_t_val); + svrax1_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svint64_t svint64_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svint64_t svint64_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrax1_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_faminmax___sme_AND_sme2_AND_faminmax.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_faminmax___sme_AND_sme2_AND_faminmax.c new file mode 100644 index 0000000..1004058 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_faminmax___sme_AND_sme2_AND_faminmax.c @@ -0,0 +1,548 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,faminmax" streaming_guard="sme,sme2,faminmax" flags="feature-dependent" + +void test(void) { + float16_t float16_t_val; + float32_t float32_t_val; + float64_t float64_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} + +void test_streaming(void) __arm_streaming{ + float16_t float16_t_val; + float32_t float32_t_val; + float64_t float64_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + float16_t float16_t_val; + float32_t float32_t_val; + float64_t float64_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8___sme_AND_sme2_AND_fp8.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8___sme_AND_sme2_AND_fp8.c new file mode 100644 index 0000000..a5735d0 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8___sme_AND_sme2_AND_fp8.c @@ -0,0 +1,206 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,fp8" streaming_guard="sme,sme2,fp8" flags="feature-dependent" + +void test(void) { + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32x2_t svfloat32x2_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnb_mf8_f32_x2_fpm(svfloat32x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnb_mf8_fpm(svfloat32x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_mf8_f32_x2_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_mf8_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming{ + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32x2_t svfloat32x2_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtlt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtn_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtn_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtn_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtn_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtnb_mf8_f32_x2_fpm(svfloat32x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtnb_mf8_fpm(svfloat32x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtnt_mf8_f32_x2_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcvtnt_mf8_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32x2_t svfloat32x2_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt1_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_bf16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_bf16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_f16_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt2_f16_mf8_fpm(svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnb_mf8_f32_x2_fpm(svfloat32x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnb_mf8_fpm(svfloat32x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_mf8_f32_x2_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_mf8_fpm(svmfloat8_t_val, svfloat32x2_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot2___sme_AND_ssve-fp8dot2.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot2___sme_AND_ssve-fp8dot2.c new file mode 100644 index 0000000..fd35929 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot2___sme_AND_ssve-fp8dot2.c @@ -0,0 +1,77 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8dot2 -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-fp8dot2 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8dot2 -target-feature +sme -target-feature +ssve-fp8dot2 -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,fp8dot2" streaming_guard="sme,ssve-fp8dot2" flags="feature-dependent" + +void test(void) { + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot4___sme_AND_ssve-fp8dot4.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot4___sme_AND_ssve-fp8dot4.c new file mode 100644 index 0000000..8bf7bf4 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8dot4___sme_AND_ssve-fp8dot4.c @@ -0,0 +1,77 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8dot4 -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-fp8dot4 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8dot4 -target-feature +sme -target-feature +ssve-fp8dot4 -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,fp8dot4" streaming_guard="sme,ssve-fp8dot4" flags="feature-dependent" + +void test(void) { + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svdot_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svdot_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8fma___sme_AND_ssve-fp8fma.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8fma___sme_AND_ssve-fp8fma.c new file mode 100644 index 0000000..7e99516 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_fp8fma___sme_AND_ssve-fp8fma.c @@ -0,0 +1,290 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8fma -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +ssve-fp8fma -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8fma -target-feature +sme -target-feature +ssve-fp8fma -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,fp8fma" streaming_guard="sme,ssve-fp8fma" flags="feature-dependent" + +void test(void) { + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming(void) __arm_streaming{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalb_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlallbt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalltt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmlalt_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + fpm_t fpm_t_val; + mfloat8_t mfloat8_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svmfloat8_t svmfloat8_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlallbt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltb_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_lane_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_lane_fpm(svfloat32_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalltt_n_f32_mf8_fpm(svfloat32_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_fpm(svfloat16_t_val, svmfloat8_t_val, svmfloat8_t_val, 2, fpm_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_f16_mf8_fpm(svfloat16_t_val, svmfloat8_t_val, mfloat8_t_val, fpm_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_lut___sme_AND_sme2_AND_lut.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_lut___sme_AND_sme2_AND_lut.c new file mode 100644 index 0000000..f54392c --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2_AND_lut___sme_AND_sme2_AND_lut.c @@ -0,0 +1,277 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2,lut" streaming_guard="sme,sme2,lut" flags="feature-dependent" + +void test(void) { + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_s8(svint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_s16(svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svbfloat16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svfloat16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint8_t_val, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint8_t_val, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_bf16_x2(svbfloat16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_f16_x2(svfloat16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s8(svint8_t_val, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s16(svint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s16_x2(svint16x2_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u8(svuint8_t_val, svuint8_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u16_x2(svuint16x2_t_val, svuint8_t_val, 2); +} + +void test_streaming(void) __arm_streaming{ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svint8_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svuint8_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_s8(svint8_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_s16(svint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_u8(svuint8_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti2_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svbfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svint8_t_val, svuint8_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svint16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svuint8_t_val, svuint8_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane(svuint16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_bf16_x2(svbfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_f16_x2(svfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_s8(svint8_t_val, svuint8_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_s16(svint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_s16_x2(svint16x2_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_u8(svuint8_t_val, svuint8_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svluti4_lane_u16_x2(svuint16x2_t_val, svuint8_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svint8_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svuint8_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_s8(svint8_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_s16(svint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_u8(svuint8_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti2_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svbfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint8_t_val, svuint8_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svint16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint8_t_val, svuint8_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane(svuint16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_bf16(svbfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_bf16_x2(svbfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_f16(svfloat16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_f16_x2(svfloat16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s8(svint8_t_val, svuint8_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s16(svint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_s16_x2(svint16x2_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u8(svuint8_t_val, svuint8_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u16(svuint16_t_val, svuint8_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svluti4_lane_u16_x2(svuint16x2_t_val, svuint8_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c new file mode 100644 index 0000000..b149f44 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c @@ -0,0 +1,16470 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2" streaming_guard="sme" flags="feature-dependent" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s8(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s16(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s32(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s64(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s8(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s8(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s16(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s32(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s64(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u16(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u32(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u64(svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint8_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint16_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint32_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s16(svint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s32(svint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s64(svint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s16(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s32(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s64(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s16(svuint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s32(svuint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s64(svuint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s16(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s32(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s64(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u16(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u32(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u64(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s16(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s32(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s64(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u16(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u32(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u64(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + svaba(svint8_t_val, svint8_t_val, int8_t_val); + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + svaba(svint16_t_val, svint16_t_val, int16_t_val); + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + svaba(svint32_t_val, svint32_t_val, int32_t_val); + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + svaba(svint64_t_val, svint64_t_val, int64_t_val); + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svabdlb(svint8_t_val, int8_t_val); + svabdlb(svint8_t_val, svint8_t_val); + svabdlb(svint16_t_val, int16_t_val); + svabdlb(svint16_t_val, svint16_t_val); + svabdlb(svint32_t_val, int32_t_val); + svabdlb(svint32_t_val, svint32_t_val); + svabdlb(svuint8_t_val, svuint8_t_val); + svabdlb(svuint8_t_val, uint8_t_val); + svabdlb(svuint16_t_val, svuint16_t_val); + svabdlb(svuint16_t_val, uint16_t_val); + svabdlb(svuint32_t_val, svuint32_t_val); + svabdlb(svuint32_t_val, uint32_t_val); + svabdlb_n_s16(svint8_t_val, int8_t_val); + svabdlb_n_s32(svint16_t_val, int16_t_val); + svabdlb_n_s64(svint32_t_val, int32_t_val); + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + svabdlb_s16(svint8_t_val, svint8_t_val); + svabdlb_s32(svint16_t_val, svint16_t_val); + svabdlb_s64(svint32_t_val, svint32_t_val); + svabdlb_u16(svuint8_t_val, svuint8_t_val); + svabdlb_u32(svuint16_t_val, svuint16_t_val); + svabdlb_u64(svuint32_t_val, svuint32_t_val); + svabdlt(svint8_t_val, int8_t_val); + svabdlt(svint8_t_val, svint8_t_val); + svabdlt(svint16_t_val, int16_t_val); + svabdlt(svint16_t_val, svint16_t_val); + svabdlt(svint32_t_val, int32_t_val); + svabdlt(svint32_t_val, svint32_t_val); + svabdlt(svuint8_t_val, svuint8_t_val); + svabdlt(svuint8_t_val, uint8_t_val); + svabdlt(svuint16_t_val, svuint16_t_val); + svabdlt(svuint16_t_val, uint16_t_val); + svabdlt(svuint32_t_val, svuint32_t_val); + svabdlt(svuint32_t_val, uint32_t_val); + svabdlt_n_s16(svint8_t_val, int8_t_val); + svabdlt_n_s32(svint16_t_val, int16_t_val); + svabdlt_n_s64(svint32_t_val, int32_t_val); + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + svabdlt_s16(svint8_t_val, svint8_t_val); + svabdlt_s32(svint16_t_val, svint16_t_val); + svabdlt_s64(svint32_t_val, svint32_t_val); + svabdlt_u16(svuint8_t_val, svuint8_t_val); + svabdlt_u32(svuint16_t_val, svuint16_t_val); + svabdlt_u64(svuint32_t_val, svuint32_t_val); + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svaddhnb(svint16_t_val, int16_t_val); + svaddhnb(svint16_t_val, svint16_t_val); + svaddhnb(svint32_t_val, int32_t_val); + svaddhnb(svint32_t_val, svint32_t_val); + svaddhnb(svint64_t_val, int64_t_val); + svaddhnb(svint64_t_val, svint64_t_val); + svaddhnb(svuint16_t_val, svuint16_t_val); + svaddhnb(svuint16_t_val, uint16_t_val); + svaddhnb(svuint32_t_val, svuint32_t_val); + svaddhnb(svuint32_t_val, uint32_t_val); + svaddhnb(svuint64_t_val, svuint64_t_val); + svaddhnb(svuint64_t_val, uint64_t_val); + svaddhnb_n_s16(svint16_t_val, int16_t_val); + svaddhnb_n_s32(svint32_t_val, int32_t_val); + svaddhnb_n_s64(svint64_t_val, int64_t_val); + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + svaddhnb_s16(svint16_t_val, svint16_t_val); + svaddhnb_s32(svint32_t_val, svint32_t_val); + svaddhnb_s64(svint64_t_val, svint64_t_val); + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svaddlb(svint8_t_val, int8_t_val); + svaddlb(svint8_t_val, svint8_t_val); + svaddlb(svint16_t_val, int16_t_val); + svaddlb(svint16_t_val, svint16_t_val); + svaddlb(svint32_t_val, int32_t_val); + svaddlb(svint32_t_val, svint32_t_val); + svaddlb(svuint8_t_val, svuint8_t_val); + svaddlb(svuint8_t_val, uint8_t_val); + svaddlb(svuint16_t_val, svuint16_t_val); + svaddlb(svuint16_t_val, uint16_t_val); + svaddlb(svuint32_t_val, svuint32_t_val); + svaddlb(svuint32_t_val, uint32_t_val); + svaddlb_n_s16(svint8_t_val, int8_t_val); + svaddlb_n_s32(svint16_t_val, int16_t_val); + svaddlb_n_s64(svint32_t_val, int32_t_val); + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + svaddlb_s16(svint8_t_val, svint8_t_val); + svaddlb_s32(svint16_t_val, svint16_t_val); + svaddlb_s64(svint32_t_val, svint32_t_val); + svaddlb_u16(svuint8_t_val, svuint8_t_val); + svaddlb_u32(svuint16_t_val, svuint16_t_val); + svaddlb_u64(svuint32_t_val, svuint32_t_val); + svaddlbt(svint8_t_val, int8_t_val); + svaddlbt(svint8_t_val, svint8_t_val); + svaddlbt(svint16_t_val, int16_t_val); + svaddlbt(svint16_t_val, svint16_t_val); + svaddlbt(svint32_t_val, int32_t_val); + svaddlbt(svint32_t_val, svint32_t_val); + svaddlbt_n_s16(svint8_t_val, int8_t_val); + svaddlbt_n_s32(svint16_t_val, int16_t_val); + svaddlbt_n_s64(svint32_t_val, int32_t_val); + svaddlbt_s16(svint8_t_val, svint8_t_val); + svaddlbt_s32(svint16_t_val, svint16_t_val); + svaddlbt_s64(svint32_t_val, svint32_t_val); + svaddlt(svint8_t_val, int8_t_val); + svaddlt(svint8_t_val, svint8_t_val); + svaddlt(svint16_t_val, int16_t_val); + svaddlt(svint16_t_val, svint16_t_val); + svaddlt(svint32_t_val, int32_t_val); + svaddlt(svint32_t_val, svint32_t_val); + svaddlt(svuint8_t_val, svuint8_t_val); + svaddlt(svuint8_t_val, uint8_t_val); + svaddlt(svuint16_t_val, svuint16_t_val); + svaddlt(svuint16_t_val, uint16_t_val); + svaddlt(svuint32_t_val, svuint32_t_val); + svaddlt(svuint32_t_val, uint32_t_val); + svaddlt_n_s16(svint8_t_val, int8_t_val); + svaddlt_n_s32(svint16_t_val, int16_t_val); + svaddlt_n_s64(svint32_t_val, int32_t_val); + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + svaddlt_s16(svint8_t_val, svint8_t_val); + svaddlt_s32(svint16_t_val, svint16_t_val); + svaddlt_s64(svint32_t_val, svint32_t_val); + svaddlt_u16(svuint8_t_val, svuint8_t_val); + svaddlt_u32(svuint16_t_val, svuint16_t_val); + svaddlt_u64(svuint32_t_val, svuint32_t_val); + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svaddwb(svint16_t_val, int8_t_val); + svaddwb(svint16_t_val, svint8_t_val); + svaddwb(svint32_t_val, int16_t_val); + svaddwb(svint32_t_val, svint16_t_val); + svaddwb(svint64_t_val, int32_t_val); + svaddwb(svint64_t_val, svint32_t_val); + svaddwb(svuint16_t_val, svuint8_t_val); + svaddwb(svuint16_t_val, uint8_t_val); + svaddwb(svuint32_t_val, svuint16_t_val); + svaddwb(svuint32_t_val, uint16_t_val); + svaddwb(svuint64_t_val, svuint32_t_val); + svaddwb(svuint64_t_val, uint32_t_val); + svaddwb_n_s16(svint16_t_val, int8_t_val); + svaddwb_n_s32(svint32_t_val, int16_t_val); + svaddwb_n_s64(svint64_t_val, int32_t_val); + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + svaddwb_s16(svint16_t_val, svint8_t_val); + svaddwb_s32(svint32_t_val, svint16_t_val); + svaddwb_s64(svint64_t_val, svint32_t_val); + svaddwb_u16(svuint16_t_val, svuint8_t_val); + svaddwb_u32(svuint32_t_val, svuint16_t_val); + svaddwb_u64(svuint64_t_val, svuint32_t_val); + svaddwt(svint16_t_val, int8_t_val); + svaddwt(svint16_t_val, svint8_t_val); + svaddwt(svint32_t_val, int16_t_val); + svaddwt(svint32_t_val, svint16_t_val); + svaddwt(svint64_t_val, int32_t_val); + svaddwt(svint64_t_val, svint32_t_val); + svaddwt(svuint16_t_val, svuint8_t_val); + svaddwt(svuint16_t_val, uint8_t_val); + svaddwt(svuint32_t_val, svuint16_t_val); + svaddwt(svuint32_t_val, uint16_t_val); + svaddwt(svuint64_t_val, svuint32_t_val); + svaddwt(svuint64_t_val, uint32_t_val); + svaddwt_n_s16(svint16_t_val, int8_t_val); + svaddwt_n_s32(svint32_t_val, int16_t_val); + svaddwt_n_s64(svint64_t_val, int32_t_val); + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + svaddwt_s16(svint16_t_val, svint8_t_val); + svaddwt_s32(svint32_t_val, svint16_t_val); + svaddwt_s64(svint64_t_val, svint32_t_val); + svaddwt_u16(svuint16_t_val, svuint8_t_val); + svaddwt_u32(svuint32_t_val, svuint16_t_val); + svaddwt_u64(svuint64_t_val, svuint32_t_val); + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcadd(svint8_t_val, svint8_t_val, 90); + svcadd(svint16_t_val, svint16_t_val, 90); + svcadd(svint32_t_val, svint32_t_val, 90); + svcadd(svint64_t_val, svint64_t_val, 90); + svcadd(svuint8_t_val, svuint8_t_val, 90); + svcadd(svuint16_t_val, svuint16_t_val, 90); + svcadd(svuint32_t_val, svuint32_t_val, 90); + svcadd(svuint64_t_val, svuint64_t_val, 90); + svcadd_s8(svint8_t_val, svint8_t_val, 90); + svcadd_s16(svint16_t_val, svint16_t_val, 90); + svcadd_s32(svint32_t_val, svint32_t_val, 90); + svcadd_s64(svint64_t_val, svint64_t_val, 90); + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svlogb_x(svbool_t_val, svfloat16_t_val); + svlogb_x(svbool_t_val, svfloat32_t_val); + svlogb_x(svbool_t_val, svfloat64_t_val); + svlogb_z(svbool_t_val, svfloat16_t_val); + svlogb_z(svbool_t_val, svfloat32_t_val); + svlogb_z(svbool_t_val, svfloat64_t_val); + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + svmovlb(svint8_t_val); + svmovlb(svint16_t_val); + svmovlb(svint32_t_val); + svmovlb(svuint8_t_val); + svmovlb(svuint16_t_val); + svmovlb(svuint32_t_val); + svmovlb_s16(svint8_t_val); + svmovlb_s32(svint16_t_val); + svmovlb_s64(svint32_t_val); + svmovlb_u16(svuint8_t_val); + svmovlb_u32(svuint16_t_val); + svmovlb_u64(svuint32_t_val); + svmovlt(svint8_t_val); + svmovlt(svint16_t_val); + svmovlt(svint32_t_val); + svmovlt(svuint8_t_val); + svmovlt(svuint16_t_val); + svmovlt(svuint32_t_val); + svmovlt_s16(svint8_t_val); + svmovlt_s32(svint16_t_val); + svmovlt_s64(svint32_t_val); + svmovlt_u16(svuint8_t_val); + svmovlt_u32(svuint16_t_val); + svmovlt_u64(svuint32_t_val); + svmul_lane(svint16_t_val, svint16_t_val, 1); + svmul_lane(svint32_t_val, svint32_t_val, 1); + svmul_lane(svint64_t_val, svint64_t_val, 1); + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + svmullb(svint8_t_val, int8_t_val); + svmullb(svint8_t_val, svint8_t_val); + svmullb(svint16_t_val, int16_t_val); + svmullb(svint16_t_val, svint16_t_val); + svmullb(svint32_t_val, int32_t_val); + svmullb(svint32_t_val, svint32_t_val); + svmullb(svuint8_t_val, svuint8_t_val); + svmullb(svuint8_t_val, uint8_t_val); + svmullb(svuint16_t_val, svuint16_t_val); + svmullb(svuint16_t_val, uint16_t_val); + svmullb(svuint32_t_val, svuint32_t_val); + svmullb(svuint32_t_val, uint32_t_val); + svmullb_lane(svint16_t_val, svint16_t_val, 1); + svmullb_lane(svint32_t_val, svint32_t_val, 1); + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullb_n_s16(svint8_t_val, int8_t_val); + svmullb_n_s32(svint16_t_val, int16_t_val); + svmullb_n_s64(svint32_t_val, int32_t_val); + svmullb_n_u16(svuint8_t_val, uint8_t_val); + svmullb_n_u32(svuint16_t_val, uint16_t_val); + svmullb_n_u64(svuint32_t_val, uint32_t_val); + svmullb_s16(svint8_t_val, svint8_t_val); + svmullb_s32(svint16_t_val, svint16_t_val); + svmullb_s64(svint32_t_val, svint32_t_val); + svmullb_u16(svuint8_t_val, svuint8_t_val); + svmullb_u32(svuint16_t_val, svuint16_t_val); + svmullb_u64(svuint32_t_val, svuint32_t_val); + svmullt(svint8_t_val, int8_t_val); + svmullt(svint8_t_val, svint8_t_val); + svmullt(svint16_t_val, int16_t_val); + svmullt(svint16_t_val, svint16_t_val); + svmullt(svint32_t_val, int32_t_val); + svmullt(svint32_t_val, svint32_t_val); + svmullt(svuint8_t_val, svuint8_t_val); + svmullt(svuint8_t_val, uint8_t_val); + svmullt(svuint16_t_val, svuint16_t_val); + svmullt(svuint16_t_val, uint16_t_val); + svmullt(svuint32_t_val, svuint32_t_val); + svmullt(svuint32_t_val, uint32_t_val); + svmullt_lane(svint16_t_val, svint16_t_val, 1); + svmullt_lane(svint32_t_val, svint32_t_val, 1); + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + svmullt_n_s16(svint8_t_val, int8_t_val); + svmullt_n_s32(svint16_t_val, int16_t_val); + svmullt_n_s64(svint32_t_val, int32_t_val); + svmullt_n_u16(svuint8_t_val, uint8_t_val); + svmullt_n_u32(svuint16_t_val, uint16_t_val); + svmullt_n_u64(svuint32_t_val, uint32_t_val); + svmullt_s16(svint8_t_val, svint8_t_val); + svmullt_s32(svint16_t_val, svint16_t_val); + svmullt_s64(svint32_t_val, svint32_t_val); + svmullt_u16(svuint8_t_val, svuint8_t_val); + svmullt_u32(svuint16_t_val, svuint16_t_val); + svmullt_u64(svuint32_t_val, svuint32_t_val); + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svpmul(svuint8_t_val, svuint8_t_val); + svpmul(svuint8_t_val, uint8_t_val); + svpmul_n_u8(svuint8_t_val, uint8_t_val); + svpmul_u8(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, svuint8_t_val); + svpmullb(svuint8_t_val, uint8_t_val); + svpmullb(svuint32_t_val, svuint32_t_val); + svpmullb(svuint32_t_val, uint32_t_val); + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + svpmullb_pair(svuint8_t_val, svuint8_t_val); + svpmullb_pair(svuint8_t_val, uint8_t_val); + svpmullb_pair(svuint32_t_val, svuint32_t_val); + svpmullb_pair(svuint32_t_val, uint32_t_val); + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullb_u16(svuint8_t_val, svuint8_t_val); + svpmullb_u64(svuint32_t_val, svuint32_t_val); + svpmullt(svuint8_t_val, svuint8_t_val); + svpmullt(svuint8_t_val, uint8_t_val); + svpmullt(svuint32_t_val, svuint32_t_val); + svpmullt(svuint32_t_val, uint32_t_val); + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + svpmullt_pair(svuint8_t_val, svuint8_t_val); + svpmullt_pair(svuint8_t_val, uint8_t_val); + svpmullt_pair(svuint32_t_val, svuint32_t_val); + svpmullt_pair(svuint32_t_val, uint32_t_val); + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + svpmullt_u16(svuint8_t_val, svuint8_t_val); + svpmullt_u64(svuint32_t_val, svuint32_t_val); + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqabs_s8_x(svbool_t_val, svint8_t_val); + svqabs_s8_z(svbool_t_val, svint8_t_val); + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqabs_s16_x(svbool_t_val, svint16_t_val); + svqabs_s16_z(svbool_t_val, svint16_t_val); + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqabs_s32_x(svbool_t_val, svint32_t_val); + svqabs_s32_z(svbool_t_val, svint32_t_val); + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqabs_s64_x(svbool_t_val, svint64_t_val); + svqabs_s64_z(svbool_t_val, svint64_t_val); + svqabs_x(svbool_t_val, svint8_t_val); + svqabs_x(svbool_t_val, svint16_t_val); + svqabs_x(svbool_t_val, svint32_t_val); + svqabs_x(svbool_t_val, svint64_t_val); + svqabs_z(svbool_t_val, svint8_t_val); + svqabs_z(svbool_t_val, svint16_t_val); + svqabs_z(svbool_t_val, svint32_t_val); + svqabs_z(svbool_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqcadd(svint8_t_val, svint8_t_val, 90); + svqcadd(svint16_t_val, svint16_t_val, 90); + svqcadd(svint32_t_val, svint32_t_val, 90); + svqcadd(svint64_t_val, svint64_t_val, 90); + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + svqdmulh(svint8_t_val, int8_t_val); + svqdmulh(svint8_t_val, svint8_t_val); + svqdmulh(svint16_t_val, int16_t_val); + svqdmulh(svint16_t_val, svint16_t_val); + svqdmulh(svint32_t_val, int32_t_val); + svqdmulh(svint32_t_val, svint32_t_val); + svqdmulh(svint64_t_val, int64_t_val); + svqdmulh(svint64_t_val, svint64_t_val); + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqdmulh_n_s8(svint8_t_val, int8_t_val); + svqdmulh_n_s16(svint16_t_val, int16_t_val); + svqdmulh_n_s32(svint32_t_val, int32_t_val); + svqdmulh_n_s64(svint64_t_val, int64_t_val); + svqdmulh_s8(svint8_t_val, svint8_t_val); + svqdmulh_s16(svint16_t_val, svint16_t_val); + svqdmulh_s32(svint32_t_val, svint32_t_val); + svqdmulh_s64(svint64_t_val, svint64_t_val); + svqdmullb(svint8_t_val, int8_t_val); + svqdmullb(svint8_t_val, svint8_t_val); + svqdmullb(svint16_t_val, int16_t_val); + svqdmullb(svint16_t_val, svint16_t_val); + svqdmullb(svint32_t_val, int32_t_val); + svqdmullb(svint32_t_val, svint32_t_val); + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullb_n_s16(svint8_t_val, int8_t_val); + svqdmullb_n_s32(svint16_t_val, int16_t_val); + svqdmullb_n_s64(svint32_t_val, int32_t_val); + svqdmullb_s16(svint8_t_val, svint8_t_val); + svqdmullb_s32(svint16_t_val, svint16_t_val); + svqdmullb_s64(svint32_t_val, svint32_t_val); + svqdmullt(svint8_t_val, int8_t_val); + svqdmullt(svint8_t_val, svint8_t_val); + svqdmullt(svint16_t_val, int16_t_val); + svqdmullt(svint16_t_val, svint16_t_val); + svqdmullt(svint32_t_val, int32_t_val); + svqdmullt(svint32_t_val, svint32_t_val); + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + svqdmullt_n_s16(svint8_t_val, int8_t_val); + svqdmullt_n_s32(svint16_t_val, int16_t_val); + svqdmullt_n_s64(svint32_t_val, int32_t_val); + svqdmullt_s16(svint8_t_val, svint8_t_val); + svqdmullt_s32(svint16_t_val, svint16_t_val); + svqdmullt_s64(svint32_t_val, svint32_t_val); + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svqneg_s8_x(svbool_t_val, svint8_t_val); + svqneg_s8_z(svbool_t_val, svint8_t_val); + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svqneg_s16_x(svbool_t_val, svint16_t_val); + svqneg_s16_z(svbool_t_val, svint16_t_val); + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svqneg_s32_x(svbool_t_val, svint32_t_val); + svqneg_s32_z(svbool_t_val, svint32_t_val); + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svqneg_s64_x(svbool_t_val, svint64_t_val); + svqneg_s64_z(svbool_t_val, svint64_t_val); + svqneg_x(svbool_t_val, svint8_t_val); + svqneg_x(svbool_t_val, svint16_t_val); + svqneg_x(svbool_t_val, svint32_t_val); + svqneg_x(svbool_t_val, svint64_t_val); + svqneg_z(svbool_t_val, svint8_t_val); + svqneg_z(svbool_t_val, svint16_t_val); + svqneg_z(svbool_t_val, svint32_t_val); + svqneg_z(svbool_t_val, svint64_t_val); + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svqrdmulh(svint8_t_val, int8_t_val); + svqrdmulh(svint8_t_val, svint8_t_val); + svqrdmulh(svint16_t_val, int16_t_val); + svqrdmulh(svint16_t_val, svint16_t_val); + svqrdmulh(svint32_t_val, int32_t_val); + svqrdmulh(svint32_t_val, svint32_t_val); + svqrdmulh(svint64_t_val, int64_t_val); + svqrdmulh(svint64_t_val, svint64_t_val); + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + svqrdmulh_s8(svint8_t_val, svint8_t_val); + svqrdmulh_s16(svint16_t_val, svint16_t_val); + svqrdmulh_s32(svint32_t_val, svint32_t_val); + svqrdmulh_s64(svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqrshrnb(svint16_t_val, 2); + svqrshrnb(svint32_t_val, 2); + svqrshrnb(svint64_t_val, 2); + svqrshrnb(svuint16_t_val, 2); + svqrshrnb(svuint32_t_val, 2); + svqrshrnb(svuint64_t_val, 2); + svqrshrnb_n_s16(svint16_t_val, 2); + svqrshrnb_n_s32(svint32_t_val, 2); + svqrshrnb_n_s64(svint64_t_val, 2); + svqrshrnb_n_u16(svuint16_t_val, 2); + svqrshrnb_n_u32(svuint32_t_val, 2); + svqrshrnb_n_u64(svuint64_t_val, 2); + svqrshrnt(svint8_t_val, svint16_t_val, 2); + svqrshrnt(svint16_t_val, svint32_t_val, 2); + svqrshrnt(svint32_t_val, svint64_t_val, 2); + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqrshrunb(svint16_t_val, 2); + svqrshrunb(svint32_t_val, 2); + svqrshrunb(svint64_t_val, 2); + svqrshrunb_n_s16(svint16_t_val, 2); + svqrshrunb_n_s32(svint32_t_val, 2); + svqrshrunb_n_s64(svint64_t_val, 2); + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svqshlu_m(svbool_t_val, svint8_t_val, 2); + svqshlu_m(svbool_t_val, svint16_t_val, 2); + svqshlu_m(svbool_t_val, svint32_t_val, 2); + svqshlu_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + svqshlu_x(svbool_t_val, svint8_t_val, 2); + svqshlu_x(svbool_t_val, svint16_t_val, 2); + svqshlu_x(svbool_t_val, svint32_t_val, 2); + svqshlu_x(svbool_t_val, svint64_t_val, 2); + svqshlu_z(svbool_t_val, svint8_t_val, 2); + svqshlu_z(svbool_t_val, svint16_t_val, 2); + svqshlu_z(svbool_t_val, svint32_t_val, 2); + svqshlu_z(svbool_t_val, svint64_t_val, 2); + svqshrnb(svint16_t_val, 2); + svqshrnb(svint32_t_val, 2); + svqshrnb(svint64_t_val, 2); + svqshrnb(svuint16_t_val, 2); + svqshrnb(svuint32_t_val, 2); + svqshrnb(svuint64_t_val, 2); + svqshrnb_n_s16(svint16_t_val, 2); + svqshrnb_n_s32(svint32_t_val, 2); + svqshrnb_n_s64(svint64_t_val, 2); + svqshrnb_n_u16(svuint16_t_val, 2); + svqshrnb_n_u32(svuint32_t_val, 2); + svqshrnb_n_u64(svuint64_t_val, 2); + svqshrnt(svint8_t_val, svint16_t_val, 2); + svqshrnt(svint16_t_val, svint32_t_val, 2); + svqshrnt(svint32_t_val, svint64_t_val, 2); + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svqshrunb(svint16_t_val, 2); + svqshrunb(svint32_t_val, 2); + svqshrunb(svint64_t_val, 2); + svqshrunb_n_s16(svint16_t_val, 2); + svqshrunb_n_s32(svint32_t_val, 2); + svqshrunb_n_s64(svint64_t_val, 2); + svqshrunt(svuint8_t_val, svint16_t_val, 2); + svqshrunt(svuint16_t_val, svint32_t_val, 2); + svqshrunt(svuint32_t_val, svint64_t_val, 2); + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svqxtnb(svint16_t_val); + svqxtnb(svint32_t_val); + svqxtnb(svint64_t_val); + svqxtnb(svuint16_t_val); + svqxtnb(svuint32_t_val); + svqxtnb(svuint64_t_val); + svqxtnb_s16(svint16_t_val); + svqxtnb_s32(svint32_t_val); + svqxtnb_s64(svint64_t_val); + svqxtnb_u16(svuint16_t_val); + svqxtnb_u32(svuint32_t_val); + svqxtnb_u64(svuint64_t_val); + svqxtnt(svint8_t_val, svint16_t_val); + svqxtnt(svint16_t_val, svint32_t_val); + svqxtnt(svint32_t_val, svint64_t_val); + svqxtnt(svuint8_t_val, svuint16_t_val); + svqxtnt(svuint16_t_val, svuint32_t_val); + svqxtnt(svuint32_t_val, svuint64_t_val); + svqxtnt_s16(svint8_t_val, svint16_t_val); + svqxtnt_s32(svint16_t_val, svint32_t_val); + svqxtnt_s64(svint32_t_val, svint64_t_val); + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + svqxtunb(svint16_t_val); + svqxtunb(svint32_t_val); + svqxtunb(svint64_t_val); + svqxtunb_s16(svint16_t_val); + svqxtunb_s32(svint32_t_val); + svqxtunb_s64(svint64_t_val); + svqxtunt(svuint8_t_val, svint16_t_val); + svqxtunt(svuint16_t_val, svint32_t_val); + svqxtunt(svuint32_t_val, svint64_t_val); + svqxtunt_s16(svuint8_t_val, svint16_t_val); + svqxtunt_s32(svuint16_t_val, svint32_t_val); + svqxtunt_s64(svuint32_t_val, svint64_t_val); + svraddhnb(svint16_t_val, int16_t_val); + svraddhnb(svint16_t_val, svint16_t_val); + svraddhnb(svint32_t_val, int32_t_val); + svraddhnb(svint32_t_val, svint32_t_val); + svraddhnb(svint64_t_val, int64_t_val); + svraddhnb(svint64_t_val, svint64_t_val); + svraddhnb(svuint16_t_val, svuint16_t_val); + svraddhnb(svuint16_t_val, uint16_t_val); + svraddhnb(svuint32_t_val, svuint32_t_val); + svraddhnb(svuint32_t_val, uint32_t_val); + svraddhnb(svuint64_t_val, svuint64_t_val); + svraddhnb(svuint64_t_val, uint64_t_val); + svraddhnb_n_s16(svint16_t_val, int16_t_val); + svraddhnb_n_s32(svint32_t_val, int32_t_val); + svraddhnb_n_s64(svint64_t_val, int64_t_val); + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + svraddhnb_s16(svint16_t_val, svint16_t_val); + svraddhnb_s32(svint32_t_val, svint32_t_val); + svraddhnb_s64(svint64_t_val, svint64_t_val); + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + svrecpe_x(svbool_t_val, svuint32_t_val); + svrecpe_z(svbool_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svrshr_m(svbool_t_val, svint8_t_val, 2); + svrshr_m(svbool_t_val, svint16_t_val, 2); + svrshr_m(svbool_t_val, svint32_t_val, 2); + svrshr_m(svbool_t_val, svint64_t_val, 2); + svrshr_m(svbool_t_val, svuint8_t_val, 2); + svrshr_m(svbool_t_val, svuint16_t_val, 2); + svrshr_m(svbool_t_val, svuint32_t_val, 2); + svrshr_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + svrshr_x(svbool_t_val, svint8_t_val, 2); + svrshr_x(svbool_t_val, svint16_t_val, 2); + svrshr_x(svbool_t_val, svint32_t_val, 2); + svrshr_x(svbool_t_val, svint64_t_val, 2); + svrshr_x(svbool_t_val, svuint8_t_val, 2); + svrshr_x(svbool_t_val, svuint16_t_val, 2); + svrshr_x(svbool_t_val, svuint32_t_val, 2); + svrshr_x(svbool_t_val, svuint64_t_val, 2); + svrshr_z(svbool_t_val, svint8_t_val, 2); + svrshr_z(svbool_t_val, svint16_t_val, 2); + svrshr_z(svbool_t_val, svint32_t_val, 2); + svrshr_z(svbool_t_val, svint64_t_val, 2); + svrshr_z(svbool_t_val, svuint8_t_val, 2); + svrshr_z(svbool_t_val, svuint16_t_val, 2); + svrshr_z(svbool_t_val, svuint32_t_val, 2); + svrshr_z(svbool_t_val, svuint64_t_val, 2); + svrshrnb(svint16_t_val, 2); + svrshrnb(svint32_t_val, 2); + svrshrnb(svint64_t_val, 2); + svrshrnb(svuint16_t_val, 2); + svrshrnb(svuint32_t_val, 2); + svrshrnb(svuint64_t_val, 2); + svrshrnb_n_s16(svint16_t_val, 2); + svrshrnb_n_s32(svint32_t_val, 2); + svrshrnb_n_s64(svint64_t_val, 2); + svrshrnb_n_u16(svuint16_t_val, 2); + svrshrnb_n_u32(svuint32_t_val, 2); + svrshrnb_n_u64(svuint64_t_val, 2); + svrshrnt(svint8_t_val, svint16_t_val, 2); + svrshrnt(svint16_t_val, svint32_t_val, 2); + svrshrnt(svint32_t_val, svint64_t_val, 2); + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + svrsqrte_x(svbool_t_val, svuint32_t_val); + svrsqrte_z(svbool_t_val, svuint32_t_val); + svrsra(svint8_t_val, svint8_t_val, 2); + svrsra(svint16_t_val, svint16_t_val, 2); + svrsra(svint32_t_val, svint32_t_val, 2); + svrsra(svint64_t_val, svint64_t_val, 2); + svrsra(svuint8_t_val, svuint8_t_val, 2); + svrsra(svuint16_t_val, svuint16_t_val, 2); + svrsra(svuint32_t_val, svuint32_t_val, 2); + svrsra(svuint64_t_val, svuint64_t_val, 2); + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svrsubhnb(svint16_t_val, int16_t_val); + svrsubhnb(svint16_t_val, svint16_t_val); + svrsubhnb(svint32_t_val, int32_t_val); + svrsubhnb(svint32_t_val, svint32_t_val); + svrsubhnb(svint64_t_val, int64_t_val); + svrsubhnb(svint64_t_val, svint64_t_val); + svrsubhnb(svuint16_t_val, svuint16_t_val); + svrsubhnb(svuint16_t_val, uint16_t_val); + svrsubhnb(svuint32_t_val, svuint32_t_val); + svrsubhnb(svuint32_t_val, uint32_t_val); + svrsubhnb(svuint64_t_val, svuint64_t_val); + svrsubhnb(svuint64_t_val, uint64_t_val); + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svrsubhnb_s16(svint16_t_val, svint16_t_val); + svrsubhnb_s32(svint32_t_val, svint32_t_val); + svrsubhnb_s64(svint64_t_val, svint64_t_val); + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svshllb(svint8_t_val, 2); + svshllb(svint16_t_val, 2); + svshllb(svint32_t_val, 2); + svshllb(svuint8_t_val, 2); + svshllb(svuint16_t_val, 2); + svshllb(svuint32_t_val, 2); + svshllb_n_s16(svint8_t_val, 2); + svshllb_n_s32(svint16_t_val, 2); + svshllb_n_s64(svint32_t_val, 2); + svshllb_n_u16(svuint8_t_val, 2); + svshllb_n_u32(svuint16_t_val, 2); + svshllb_n_u64(svuint32_t_val, 2); + svshllt(svint8_t_val, 2); + svshllt(svint16_t_val, 2); + svshllt(svint32_t_val, 2); + svshllt(svuint8_t_val, 2); + svshllt(svuint16_t_val, 2); + svshllt(svuint32_t_val, 2); + svshllt_n_s16(svint8_t_val, 2); + svshllt_n_s32(svint16_t_val, 2); + svshllt_n_s64(svint32_t_val, 2); + svshllt_n_u16(svuint8_t_val, 2); + svshllt_n_u32(svuint16_t_val, 2); + svshllt_n_u64(svuint32_t_val, 2); + svshrnb(svint16_t_val, 2); + svshrnb(svint32_t_val, 2); + svshrnb(svint64_t_val, 2); + svshrnb(svuint16_t_val, 2); + svshrnb(svuint32_t_val, 2); + svshrnb(svuint64_t_val, 2); + svshrnb_n_s16(svint16_t_val, 2); + svshrnb_n_s32(svint32_t_val, 2); + svshrnb_n_s64(svint64_t_val, 2); + svshrnb_n_u16(svuint16_t_val, 2); + svshrnb_n_u32(svuint32_t_val, 2); + svshrnb_n_u64(svuint64_t_val, 2); + svshrnt(svint8_t_val, svint16_t_val, 2); + svshrnt(svint16_t_val, svint32_t_val, 2); + svshrnt(svint32_t_val, svint64_t_val, 2); + svshrnt(svuint8_t_val, svuint16_t_val, 2); + svshrnt(svuint16_t_val, svuint32_t_val, 2); + svshrnt(svuint32_t_val, svuint64_t_val, 2); + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + svsli(svint8_t_val, svint8_t_val, 2); + svsli(svint16_t_val, svint16_t_val, 2); + svsli(svint32_t_val, svint32_t_val, 2); + svsli(svint64_t_val, svint64_t_val, 2); + svsli(svuint8_t_val, svuint8_t_val, 2); + svsli(svuint16_t_val, svuint16_t_val, 2); + svsli(svuint32_t_val, svuint32_t_val, 2); + svsli(svuint64_t_val, svuint64_t_val, 2); + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + svsra(svint8_t_val, svint8_t_val, 2); + svsra(svint16_t_val, svint16_t_val, 2); + svsra(svint32_t_val, svint32_t_val, 2); + svsra(svint64_t_val, svint64_t_val, 2); + svsra(svuint8_t_val, svuint8_t_val, 2); + svsra(svuint16_t_val, svuint16_t_val, 2); + svsra(svuint32_t_val, svuint32_t_val, 2); + svsra(svuint64_t_val, svuint64_t_val, 2); + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsri(svint8_t_val, svint8_t_val, 2); + svsri(svint16_t_val, svint16_t_val, 2); + svsri(svint32_t_val, svint32_t_val, 2); + svsri(svint64_t_val, svint64_t_val, 2); + svsri(svuint8_t_val, svuint8_t_val, 2); + svsri(svuint16_t_val, svuint16_t_val, 2); + svsri(svuint32_t_val, svuint32_t_val, 2); + svsri(svuint64_t_val, svuint64_t_val, 2); + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + svsubhnb(svint16_t_val, int16_t_val); + svsubhnb(svint16_t_val, svint16_t_val); + svsubhnb(svint32_t_val, int32_t_val); + svsubhnb(svint32_t_val, svint32_t_val); + svsubhnb(svint64_t_val, int64_t_val); + svsubhnb(svint64_t_val, svint64_t_val); + svsubhnb(svuint16_t_val, svuint16_t_val); + svsubhnb(svuint16_t_val, uint16_t_val); + svsubhnb(svuint32_t_val, svuint32_t_val); + svsubhnb(svuint32_t_val, uint32_t_val); + svsubhnb(svuint64_t_val, svuint64_t_val); + svsubhnb(svuint64_t_val, uint64_t_val); + svsubhnb_n_s16(svint16_t_val, int16_t_val); + svsubhnb_n_s32(svint32_t_val, int32_t_val); + svsubhnb_n_s64(svint64_t_val, int64_t_val); + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + svsubhnb_s16(svint16_t_val, svint16_t_val); + svsubhnb_s32(svint32_t_val, svint32_t_val); + svsubhnb_s64(svint64_t_val, svint64_t_val); + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + svsublb(svint8_t_val, int8_t_val); + svsublb(svint8_t_val, svint8_t_val); + svsublb(svint16_t_val, int16_t_val); + svsublb(svint16_t_val, svint16_t_val); + svsublb(svint32_t_val, int32_t_val); + svsublb(svint32_t_val, svint32_t_val); + svsublb(svuint8_t_val, svuint8_t_val); + svsublb(svuint8_t_val, uint8_t_val); + svsublb(svuint16_t_val, svuint16_t_val); + svsublb(svuint16_t_val, uint16_t_val); + svsublb(svuint32_t_val, svuint32_t_val); + svsublb(svuint32_t_val, uint32_t_val); + svsublb_n_s16(svint8_t_val, int8_t_val); + svsublb_n_s32(svint16_t_val, int16_t_val); + svsublb_n_s64(svint32_t_val, int32_t_val); + svsublb_n_u16(svuint8_t_val, uint8_t_val); + svsublb_n_u32(svuint16_t_val, uint16_t_val); + svsublb_n_u64(svuint32_t_val, uint32_t_val); + svsublb_s16(svint8_t_val, svint8_t_val); + svsublb_s32(svint16_t_val, svint16_t_val); + svsublb_s64(svint32_t_val, svint32_t_val); + svsublb_u16(svuint8_t_val, svuint8_t_val); + svsublb_u32(svuint16_t_val, svuint16_t_val); + svsublb_u64(svuint32_t_val, svuint32_t_val); + svsublbt(svint8_t_val, int8_t_val); + svsublbt(svint8_t_val, svint8_t_val); + svsublbt(svint16_t_val, int16_t_val); + svsublbt(svint16_t_val, svint16_t_val); + svsublbt(svint32_t_val, int32_t_val); + svsublbt(svint32_t_val, svint32_t_val); + svsublbt_n_s16(svint8_t_val, int8_t_val); + svsublbt_n_s32(svint16_t_val, int16_t_val); + svsublbt_n_s64(svint32_t_val, int32_t_val); + svsublbt_s16(svint8_t_val, svint8_t_val); + svsublbt_s32(svint16_t_val, svint16_t_val); + svsublbt_s64(svint32_t_val, svint32_t_val); + svsublt(svint8_t_val, int8_t_val); + svsublt(svint8_t_val, svint8_t_val); + svsublt(svint16_t_val, int16_t_val); + svsublt(svint16_t_val, svint16_t_val); + svsublt(svint32_t_val, int32_t_val); + svsublt(svint32_t_val, svint32_t_val); + svsublt(svuint8_t_val, svuint8_t_val); + svsublt(svuint8_t_val, uint8_t_val); + svsublt(svuint16_t_val, svuint16_t_val); + svsublt(svuint16_t_val, uint16_t_val); + svsublt(svuint32_t_val, svuint32_t_val); + svsublt(svuint32_t_val, uint32_t_val); + svsublt_n_s16(svint8_t_val, int8_t_val); + svsublt_n_s32(svint16_t_val, int16_t_val); + svsublt_n_s64(svint32_t_val, int32_t_val); + svsublt_n_u16(svuint8_t_val, uint8_t_val); + svsublt_n_u32(svuint16_t_val, uint16_t_val); + svsublt_n_u64(svuint32_t_val, uint32_t_val); + svsublt_s16(svint8_t_val, svint8_t_val); + svsublt_s32(svint16_t_val, svint16_t_val); + svsublt_s64(svint32_t_val, svint32_t_val); + svsublt_u16(svuint8_t_val, svuint8_t_val); + svsublt_u32(svuint16_t_val, svuint16_t_val); + svsublt_u64(svuint32_t_val, svuint32_t_val); + svsubltb(svint8_t_val, int8_t_val); + svsubltb(svint8_t_val, svint8_t_val); + svsubltb(svint16_t_val, int16_t_val); + svsubltb(svint16_t_val, svint16_t_val); + svsubltb(svint32_t_val, int32_t_val); + svsubltb(svint32_t_val, svint32_t_val); + svsubltb_n_s16(svint8_t_val, int8_t_val); + svsubltb_n_s32(svint16_t_val, int16_t_val); + svsubltb_n_s64(svint32_t_val, int32_t_val); + svsubltb_s16(svint8_t_val, svint8_t_val); + svsubltb_s32(svint16_t_val, svint16_t_val); + svsubltb_s64(svint32_t_val, svint32_t_val); + svsubwb(svint16_t_val, int8_t_val); + svsubwb(svint16_t_val, svint8_t_val); + svsubwb(svint32_t_val, int16_t_val); + svsubwb(svint32_t_val, svint16_t_val); + svsubwb(svint64_t_val, int32_t_val); + svsubwb(svint64_t_val, svint32_t_val); + svsubwb(svuint16_t_val, svuint8_t_val); + svsubwb(svuint16_t_val, uint8_t_val); + svsubwb(svuint32_t_val, svuint16_t_val); + svsubwb(svuint32_t_val, uint16_t_val); + svsubwb(svuint64_t_val, svuint32_t_val); + svsubwb(svuint64_t_val, uint32_t_val); + svsubwb_n_s16(svint16_t_val, int8_t_val); + svsubwb_n_s32(svint32_t_val, int16_t_val); + svsubwb_n_s64(svint64_t_val, int32_t_val); + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + svsubwb_s16(svint16_t_val, svint8_t_val); + svsubwb_s32(svint32_t_val, svint16_t_val); + svsubwb_s64(svint64_t_val, svint32_t_val); + svsubwb_u16(svuint16_t_val, svuint8_t_val); + svsubwb_u32(svuint32_t_val, svuint16_t_val); + svsubwb_u64(svuint64_t_val, svuint32_t_val); + svsubwt(svint16_t_val, int8_t_val); + svsubwt(svint16_t_val, svint8_t_val); + svsubwt(svint32_t_val, int16_t_val); + svsubwt(svint32_t_val, svint16_t_val); + svsubwt(svint64_t_val, int32_t_val); + svsubwt(svint64_t_val, svint32_t_val); + svsubwt(svuint16_t_val, svuint8_t_val); + svsubwt(svuint16_t_val, uint8_t_val); + svsubwt(svuint32_t_val, svuint16_t_val); + svsubwt(svuint32_t_val, uint16_t_val); + svsubwt(svuint64_t_val, svuint32_t_val); + svsubwt(svuint64_t_val, uint32_t_val); + svsubwt_n_s16(svint16_t_val, int8_t_val); + svsubwt_n_s32(svint32_t_val, int16_t_val); + svsubwt_n_s64(svint64_t_val, int32_t_val); + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + svsubwt_s16(svint16_t_val, svint8_t_val); + svsubwt_s32(svint32_t_val, svint16_t_val); + svsubwt_s64(svint64_t_val, svint32_t_val); + svsubwt_u16(svuint16_t_val, svuint8_t_val); + svsubwt_u32(svuint32_t_val, svuint16_t_val); + svsubwt_u64(svuint64_t_val, svuint32_t_val); + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat16x2_t_val, svuint16_t_val); + svtbl2(svfloat32x2_t_val, svuint32_t_val); + svtbl2(svfloat64x2_t_val, svuint64_t_val); + svtbl2(svint8x2_t_val, svuint8_t_val); + svtbl2(svint16x2_t_val, svuint16_t_val); + svtbl2(svint32x2_t_val, svuint32_t_val); + svtbl2(svint64x2_t_val, svuint64_t_val); + svtbl2(svuint8x2_t_val, svuint8_t_val); + svtbl2(svuint16x2_t_val, svuint16_t_val); + svtbl2(svuint32x2_t_val, svuint32_t_val); + svtbl2(svuint64x2_t_val, svuint64_t_val); + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + svwhilege_b8(int32_t_val, int32_t_val); + svwhilege_b8(int64_t_val, int64_t_val); + svwhilege_b8(uint32_t_val, uint32_t_val); + svwhilege_b8(uint64_t_val, uint64_t_val); + svwhilege_b8_s32(int32_t_val, int32_t_val); + svwhilege_b8_s64(int64_t_val, int64_t_val); + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + svwhilege_b16(int32_t_val, int32_t_val); + svwhilege_b16(int64_t_val, int64_t_val); + svwhilege_b16(uint32_t_val, uint32_t_val); + svwhilege_b16(uint64_t_val, uint64_t_val); + svwhilege_b16_s32(int32_t_val, int32_t_val); + svwhilege_b16_s64(int64_t_val, int64_t_val); + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + svwhilege_b32(int32_t_val, int32_t_val); + svwhilege_b32(int64_t_val, int64_t_val); + svwhilege_b32(uint32_t_val, uint32_t_val); + svwhilege_b32(uint64_t_val, uint64_t_val); + svwhilege_b32_s32(int32_t_val, int32_t_val); + svwhilege_b32_s64(int64_t_val, int64_t_val); + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + svwhilege_b64(int32_t_val, int32_t_val); + svwhilege_b64(int64_t_val, int64_t_val); + svwhilege_b64(uint32_t_val, uint32_t_val); + svwhilege_b64(uint64_t_val, uint64_t_val); + svwhilege_b64_s32(int32_t_val, int32_t_val); + svwhilege_b64_s64(int64_t_val, int64_t_val); + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + svwhilegt_b8(int32_t_val, int32_t_val); + svwhilegt_b8(int64_t_val, int64_t_val); + svwhilegt_b8(uint32_t_val, uint32_t_val); + svwhilegt_b8(uint64_t_val, uint64_t_val); + svwhilegt_b8_s32(int32_t_val, int32_t_val); + svwhilegt_b8_s64(int64_t_val, int64_t_val); + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + svwhilegt_b16(int32_t_val, int32_t_val); + svwhilegt_b16(int64_t_val, int64_t_val); + svwhilegt_b16(uint32_t_val, uint32_t_val); + svwhilegt_b16(uint64_t_val, uint64_t_val); + svwhilegt_b16_s32(int32_t_val, int32_t_val); + svwhilegt_b16_s64(int64_t_val, int64_t_val); + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + svwhilegt_b32(int32_t_val, int32_t_val); + svwhilegt_b32(int64_t_val, int64_t_val); + svwhilegt_b32(uint32_t_val, uint32_t_val); + svwhilegt_b32(uint64_t_val, uint64_t_val); + svwhilegt_b32_s32(int32_t_val, int32_t_val); + svwhilegt_b32_s64(int64_t_val, int64_t_val); + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + svwhilegt_b64(int32_t_val, int32_t_val); + svwhilegt_b64(int64_t_val, int64_t_val); + svwhilegt_b64(uint32_t_val, uint32_t_val); + svwhilegt_b64(uint64_t_val, uint64_t_val); + svwhilegt_b64_s32(int32_t_val, int32_t_val); + svwhilegt_b64_s64(int64_t_val, int64_t_val); + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + svxar(svint8_t_val, svint8_t_val, 2); + svxar(svint16_t_val, svint16_t_val, 2); + svxar(svint32_t_val, svint32_t_val, 2); + svxar(svint64_t_val, svint64_t_val, 2); + svxar(svuint8_t_val, svuint8_t_val, 2); + svxar(svuint16_t_val, svuint16_t_val, 2); + svxar(svuint32_t_val, svuint32_t_val, 2); + svxar(svuint64_t_val, svuint64_t_val, 2); + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaba_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svabdlt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_m(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_x(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s16_z(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_m(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_x(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s32_z(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_m(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_x(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_s64_z(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_m(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u16_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_m(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u32_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_m(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_u64_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_x(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadalp_z(svbool_t_val, svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlbt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddlt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwb_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svaddwt_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbcax_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl1n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl2n_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd(svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s8(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s16(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s32(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_s64(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u8(svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u16(svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u32(svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcadd_u64(svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot(svint32_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot(svint64_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_s32(svint32_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcdot_s64(svint64_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcmla_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_f16_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f32_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_f32_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtlt_f64_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_f64_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtx_f32_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtxnt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtxnt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveor3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveorbt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + sveortb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svhsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f16_z(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f32_z(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_f64_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_x(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svlogb_z(svbool_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnmp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminp_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmla_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlalt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmls_lane_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslb_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_f32(svfloat32_t_val, svfloat16_t_val, svfloat16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_lane_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_f32(svfloat32_t_val, svfloat16_t_val, float16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u16(svuint16_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u32(svuint32_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_n_u64(svuint64_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u16(svuint16_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u32(svuint32_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmlslt_u64(svuint64_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlb_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmovlt_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane(svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u16(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u32(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmul_lane_u64(svuint64_t_val, svuint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_u32(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_lane_u64(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_u32(svuint16_t_val, svuint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_lane_u64(svuint32_t_val, svuint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmullt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u8(svuint8_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u16(svuint16_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svnbsl_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmul_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_pair_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u8(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u8(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_pair_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpmullt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s8_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s16_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s32_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_s64_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqabs_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s8(svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s16(svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s32(svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcadd_s64(svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlalt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslb_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslbt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane_s32(svint32_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_lane_s64(svint64_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s16(svint16_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s32(svint32_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_n_s64(svint64_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s16(svint16_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s32(svint32_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmlslt_s64(svint64_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s8(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane_s32(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_lane_s64(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmullt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s8_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s16_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s32_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_s64_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_x(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqneg_z(svbool_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdcmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val, 90); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlah_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s16(svint16_t_val, svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s32(svint32_t_val, svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_lane_s64(svint64_t_val, svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s8(svint8_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s16(svint16_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s32(svint32_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_n_s64(svint64_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s8(svint8_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s16(svint16_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s32(svint32_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmlsh_s64(svint64_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s16(svint16_t_val, svint16_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s32(svint32_t_val, svint32_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_lane_s64(svint64_t_val, svint64_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s8(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s8(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrdmulh_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s8_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s16_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s32_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_n_s64_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshlu_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s16(svuint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s32(svuint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqshrunt_n_s64(svuint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb(svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s16(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s32(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_s64(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u16(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u32(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnb_u64(svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint8_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint16_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt(svuint32_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s16(svint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s32(svint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_s64(svint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u16(svuint8_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u32(svuint16_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtnt_u64(svuint32_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s16(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s32(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunb_s64(svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt(svuint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s16(svuint8_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s32(svuint16_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqxtunt_s64(svuint32_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svraddhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_u32_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrecpe_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrhadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_m(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_m(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s8_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_m(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s16_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_m(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s32_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_m(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_s64_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_m(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_x(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u8_z(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_m(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_x(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u16_z(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_m(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_x(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u32_z(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_m(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_x(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_n_u64_z(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_x(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshr_z(svbool_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_u32_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_x(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsqrte_z(svbool_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclb_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_n_u32(svuint32_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_n_u64(svuint64_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsbclt_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s16(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s32(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_s64(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u16(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u32(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllb_n_u64(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s16(svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s32(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_s64(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u16(svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u32(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshllt_n_u64(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s16(svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s32(svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_s64(svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u16(svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u32(svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnb_n_u64(svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s16(svint8_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s32(svint16_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_s64(svint32_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u16(svuint8_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u32(svuint16_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svshrnt_n_u64(svuint32_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsli_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_m(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u8_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_m(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u16_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_m(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u32_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_m(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_n_u64_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_m(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u8_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_m(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u16_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_m(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u32_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_m(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_u64_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_x(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsqadd_z(svbool_t_val, svuint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsra_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsri_n_u64(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s16(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s32(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_s64(svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u16(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u32(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_n_u64(svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s16(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s32(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_s64(svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u16(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u32(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnb_u64(svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s16(svint8_t_val, svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s32(svint16_t_val, svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_s64(svint32_t_val, svint64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u16(svuint8_t_val, svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u32(svuint16_t_val, svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_n_u64(svuint32_t_val, svuint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s16(svint8_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s32(svint16_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_s64(svint32_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u16(svuint8_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u32(svuint16_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubhnt_u64(svuint32_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublb_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublbt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u16(svuint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u32(svuint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_n_u64(svuint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u16(svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u32(svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsublt_u64(svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s16(svint8_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s32(svint16_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_n_s64(svint32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s16(svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s32(svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubltb_s64(svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwb_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s16(svint16_t_val, int8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s32(svint32_t_val, int16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_s64(svint64_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u16(svuint16_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u32(svuint32_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_n_u64(svuint64_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s16(svint16_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s32(svint32_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_s64(svint64_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u16(svuint16_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u32(svuint32_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsubwt_u64(svuint64_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svbfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svfloat64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_bf16(svbfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f16(svfloat16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f32(svfloat32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_f64(svfloat64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s8(svint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s16(svint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s32(svint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_s64(svint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u8(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u16(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u32(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbl2_u64(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint8_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint16_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint32_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svint64_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_bf16(svbfloat16_t_val, svbfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f16(svfloat16_t_val, svfloat16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f32(svfloat32_t_val, svfloat32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_f64(svfloat64_t_val, svfloat64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s8(svint8_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s16(svint16_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s32(svint32_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_s64(svint64_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svtbx_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_m(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_x(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint8_t_val, uint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint16_t_val, uint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuqadd_z(svbool_t_val, svint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b8_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b16_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b32_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_b64_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b8_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b16_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b32_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_s32(int32_t_val, int32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_s64(int64_t_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_u32(uint32_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_b64_u64(uint64_t_val, uint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f16(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f32(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_f64(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s8(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s16(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s32(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_s64(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u8(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u16(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u32(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilerw_u64(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_bf16(bfloat16_t_ptr_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f16(float16_t_ptr_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f32(float32_t_ptr_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_f64(float64_t_ptr_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s8(int8_t_ptr_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s16(int16_t_ptr_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s32(int32_t_ptr_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_s64(int64_t_ptr_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u8(uint8_t_ptr_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u16(uint16_t_ptr_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u32(uint32_t_ptr_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilewr_u64(uint64_t_ptr_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar(svuint64_t_val, svuint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s8(svint8_t_val, svint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s16(svint16_t_val, svint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s32(svint32_t_val, svint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_s64(svint64_t_val, svint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u8(svuint8_t_val, svuint8_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u16(svuint16_t_val, svuint16_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u32(svuint32_t_val, svuint32_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svxar_n_u64(svuint64_t_val, svuint64_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_sme2.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_sme2.c new file mode 100644 index 0000000..104d0f3 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2p1___sme_AND_sme2.c @@ -0,0 +1,3690 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve2p1 -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2p1" streaming_guard="sme,sme2" flags="feature-dependent" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svcount_t svcount_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c8(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c16(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c32(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c64(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f16_x2(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f16_x4(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f32_x2(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f32_x4(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f64_x2(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f64_x4(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s8_x2(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s8_x4(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s16_x2(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s16_x4(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s32_x2(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s32_x4(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s64_x2(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s64_x4(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f16_x2(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f16_x4(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f32_x2(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f32_x4(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f64_x2(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f64_x4(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s8_x2(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s8_x4(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s16_x2(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s16_x4(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s32_x2(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s32_x4(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s64_x2(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s64_x4(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, bfloat16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, mfloat8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint8_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint16_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint32_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint64_t_ptr_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c8(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c8_x2(svcount_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c16(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c16_x2(svcount_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c32(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c32_x2(svcount_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c64(svcount_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c64_x2(svcount_t_val, 1); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpfalse_c(); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c8(svcount_t_val, svbool_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c16(svcount_t_val, svbool_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c32(svcount_t_val, svbool_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c64(svcount_t_val, svbool_t_val, uint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c8(); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c16(); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c32(); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c64(); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret(svbool_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret(svcount_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret_b(svcount_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret_c(svbool_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32_u64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64(uint64_t_val, uint64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64_s64(int64_t_val, int64_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64_u64(uint64_t_val, uint64_t_val, 2); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svcount_t svcount_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcntp_c8(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcntp_c16(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcntp_c32(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcntp_c64(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f16_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f16_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f32_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f32_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f64_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_f64_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s8_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s8_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s16_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s16_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s32_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s32_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s64_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_s64_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f16_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f16_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f32_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f32_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f64_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_f64_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s8_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s8_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s16_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s16_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s32_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s32_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s64_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_s64_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c8(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c8_x2(svcount_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c16(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c16_x2(svcount_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c32(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c32_x2(svcount_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c64(svcount_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpext_lane_c64_x2(svcount_t_val, 1); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpfalse_c(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpsel_lane_c8(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpsel_lane_c16(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpsel_lane_c32(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svpsel_lane_c64(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svptrue_c8(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svptrue_c16(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svptrue_c32(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svptrue_c64(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svreinterpret(svbool_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svreinterpret(svcount_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svreinterpret_b(svcount_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svreinterpret_c(svbool_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c8(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c16(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c32(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilege_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c8(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c16(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c32(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilegt_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c8(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c16(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c32(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilele_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c8(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c16(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c32(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwhilelt_c64_u64(uint64_t_val, uint64_t_val, 2); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svcount_t svcount_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c8(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c16(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c32(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcntp_c64(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f16_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f16_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f32_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f32_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f64_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_f64_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s8_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s8_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s16_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s16_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s32_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s32_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s64_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_s64_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svld1_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f16_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f16_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f32_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f32_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f64_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_f64_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s8_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s8_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s16_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s16_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s32_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s32_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s64_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_s64_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u8_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u8_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u16_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u16_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u32_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u32_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u64_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_u64_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_vnum_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x2(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, bfloat16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, float64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, int64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, mfloat8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint8_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint16_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint32_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svldnt1_x4(svcount_t_val, uint64_t_ptr_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c8(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c8_x2(svcount_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c16(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c16_x2(svcount_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c32(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c32_x2(svcount_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c64(svcount_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpext_lane_c64_x2(svcount_t_val, 1); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpfalse_c(); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c8(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c16(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c32(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svpsel_lane_c64(svcount_t_val, svbool_t_val, uint32_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c8(); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c16(); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c32(); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svptrue_c64(); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret(svbool_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret(svcount_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret_b(svcount_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svreinterpret_c(svbool_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svst1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f16_x2(svcount_t_val, float16_t_ptr_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f16_x4(svcount_t_val, float16_t_ptr_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f32_x2(svcount_t_val, float32_t_ptr_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f32_x4(svcount_t_val, float32_t_ptr_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f64_x2(svcount_t_val, float64_t_ptr_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_f64_x4(svcount_t_val, float64_t_ptr_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s8_x2(svcount_t_val, int8_t_ptr_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s8_x4(svcount_t_val, int8_t_ptr_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s16_x2(svcount_t_val, int16_t_ptr_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s16_x4(svcount_t_val, int16_t_ptr_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s32_x2(svcount_t_val, int32_t_ptr_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s32_x4(svcount_t_val, int32_t_ptr_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s64_x2(svcount_t_val, int64_t_ptr_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_s64_x4(svcount_t_val, int64_t_ptr_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u8_x2(svcount_t_val, uint8_t_ptr_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u8_x4(svcount_t_val, uint8_t_ptr_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u16_x2(svcount_t_val, uint16_t_ptr_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u16_x4(svcount_t_val, uint16_t_ptr_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u32_x2(svcount_t_val, uint32_t_ptr_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u32_x4(svcount_t_val, uint32_t_ptr_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u64_x2(svcount_t_val, uint64_t_ptr_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_u64_x4(svcount_t_val, uint64_t_ptr_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_bf16_x2(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_bf16_x4(svcount_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f16_x2(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f16_x4(svcount_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f32_x2(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f32_x4(svcount_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f64_x2(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_f64_x4(svcount_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_mf8_x2(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_mf8_x4(svcount_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s8_x2(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s8_x4(svcount_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s16_x2(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s16_x4(svcount_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s32_x2(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s32_x4(svcount_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s64_x2(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_s64_x4(svcount_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u8_x2(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u8_x4(svcount_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u16_x2(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u16_x4(svcount_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u32_x2(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u32_x4(svcount_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u64_x2(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svstnt1_vnum_u64_x4(svcount_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilege_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilegt_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilele_c64_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c8_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c16_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c32_u64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64(uint64_t_val, uint64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64_s64(int64_t_val, int64_t_val, 2); + // guard-error@+2 {{builtin can only be called from a non-streaming function}} + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svwhilelt_c64_u64(uint64_t_val, uint64_t_val, 2); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme.c new file mode 100644 index 0000000..78db4a6 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme.c @@ -0,0 +1,19470 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve" streaming_guard="sme" flags="feature-dependent" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + bfloat16_t bfloat16_t_val; + bool bool_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + void * void_ptr_val; + + svabd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabs_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_f16_x(svbool_t_val, svfloat16_t_val); + svabs_f16_z(svbool_t_val, svfloat16_t_val); + svabs_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_f32_x(svbool_t_val, svfloat32_t_val); + svabs_f32_z(svbool_t_val, svfloat32_t_val); + svabs_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_f64_x(svbool_t_val, svfloat64_t_val); + svabs_f64_z(svbool_t_val, svfloat64_t_val); + svabs_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_s8_x(svbool_t_val, svint8_t_val); + svabs_s8_z(svbool_t_val, svint8_t_val); + svabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_s16_x(svbool_t_val, svint16_t_val); + svabs_s16_z(svbool_t_val, svint16_t_val); + svabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_s32_x(svbool_t_val, svint32_t_val); + svabs_s32_z(svbool_t_val, svint32_t_val); + svabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s64_x(svbool_t_val, svint64_t_val); + svabs_s64_z(svbool_t_val, svint64_t_val); + svabs_x(svbool_t_val, svfloat16_t_val); + svabs_x(svbool_t_val, svfloat32_t_val); + svabs_x(svbool_t_val, svfloat64_t_val); + svabs_x(svbool_t_val, svint8_t_val); + svabs_x(svbool_t_val, svint16_t_val); + svabs_x(svbool_t_val, svint32_t_val); + svabs_x(svbool_t_val, svint64_t_val); + svabs_z(svbool_t_val, svfloat16_t_val); + svabs_z(svbool_t_val, svfloat32_t_val); + svabs_z(svbool_t_val, svfloat64_t_val); + svabs_z(svbool_t_val, svint8_t_val); + svabs_z(svbool_t_val, svint16_t_val); + svabs_z(svbool_t_val, svint32_t_val); + svabs_z(svbool_t_val, svint64_t_val); + svacge(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge(svbool_t_val, svfloat64_t_val, float64_t_val); + svacge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svaddv(svbool_t_val, svfloat16_t_val); + svaddv(svbool_t_val, svfloat32_t_val); + svaddv(svbool_t_val, svfloat64_t_val); + svaddv(svbool_t_val, svint8_t_val); + svaddv(svbool_t_val, svint16_t_val); + svaddv(svbool_t_val, svint32_t_val); + svaddv(svbool_t_val, svint64_t_val); + svaddv(svbool_t_val, svuint8_t_val); + svaddv(svbool_t_val, svuint16_t_val); + svaddv(svbool_t_val, svuint32_t_val); + svaddv(svbool_t_val, svuint64_t_val); + svaddv_f16(svbool_t_val, svfloat16_t_val); + svaddv_f32(svbool_t_val, svfloat32_t_val); + svaddv_f64(svbool_t_val, svfloat64_t_val); + svaddv_s8(svbool_t_val, svint8_t_val); + svaddv_s16(svbool_t_val, svint16_t_val); + svaddv_s32(svbool_t_val, svint32_t_val); + svaddv_s64(svbool_t_val, svint64_t_val); + svaddv_u8(svbool_t_val, svuint8_t_val); + svaddv_u16(svbool_t_val, svuint16_t_val); + svaddv_u32(svbool_t_val, svuint32_t_val); + svaddv_u64(svbool_t_val, svuint64_t_val); + svand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svandv(svbool_t_val, svint8_t_val); + svandv(svbool_t_val, svint16_t_val); + svandv(svbool_t_val, svint32_t_val); + svandv(svbool_t_val, svint64_t_val); + svandv(svbool_t_val, svuint8_t_val); + svandv(svbool_t_val, svuint16_t_val); + svandv(svbool_t_val, svuint32_t_val); + svandv(svbool_t_val, svuint64_t_val); + svandv_s8(svbool_t_val, svint8_t_val); + svandv_s16(svbool_t_val, svint16_t_val); + svandv_s32(svbool_t_val, svint32_t_val); + svandv_s64(svbool_t_val, svint64_t_val); + svandv_u8(svbool_t_val, svuint8_t_val); + svandv_u16(svbool_t_val, svuint16_t_val); + svandv_u32(svbool_t_val, svuint32_t_val); + svandv_u64(svbool_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasrd_m(svbool_t_val, svint8_t_val, 2); + svasrd_m(svbool_t_val, svint16_t_val, 2); + svasrd_m(svbool_t_val, svint32_t_val, 2); + svasrd_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s8_m(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_x(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_z(svbool_t_val, svint8_t_val, 2); + svasrd_n_s16_m(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_x(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_z(svbool_t_val, svint16_t_val, 2); + svasrd_n_s32_m(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_x(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_z(svbool_t_val, svint32_t_val, 2); + svasrd_n_s64_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_x(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_z(svbool_t_val, svint64_t_val, 2); + svasrd_x(svbool_t_val, svint8_t_val, 2); + svasrd_x(svbool_t_val, svint16_t_val, 2); + svasrd_x(svbool_t_val, svint32_t_val, 2); + svasrd_x(svbool_t_val, svint64_t_val, 2); + svasrd_z(svbool_t_val, svint8_t_val, 2); + svasrd_z(svbool_t_val, svint16_t_val, 2); + svasrd_z(svbool_t_val, svint32_t_val, 2); + svasrd_z(svbool_t_val, svint64_t_val, 2); + svbic_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbrka_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_b_z(svbool_t_val, svbool_t_val); + svbrka_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_z(svbool_t_val, svbool_t_val); + svbrkb_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_b_z(svbool_t_val, svbool_t_val); + svbrkb_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_z(svbool_t_val, svbool_t_val); + svbrkn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_z(svbool_t_val, svbool_t_val, svbool_t_val); + svcadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svclasta(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, int8_t_val, svint8_t_val); + svclasta(svbool_t_val, int16_t_val, svint16_t_val); + svclasta(svbool_t_val, int32_t_val, svint32_t_val); + svclasta(svbool_t_val, int64_t_val, svint64_t_val); + svclasta(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclasta(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclasta_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclasta_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclasta_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclasta_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, int8_t_val, svint8_t_val); + svclastb(svbool_t_val, int16_t_val, svint16_t_val); + svclastb(svbool_t_val, int32_t_val, svint32_t_val); + svclastb(svbool_t_val, int64_t_val, svint64_t_val); + svclastb(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclastb_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclastb_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclastb_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclastb_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcls_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_s8_x(svbool_t_val, svint8_t_val); + svcls_s8_z(svbool_t_val, svint8_t_val); + svcls_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_s16_x(svbool_t_val, svint16_t_val); + svcls_s16_z(svbool_t_val, svint16_t_val); + svcls_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_s32_x(svbool_t_val, svint32_t_val); + svcls_s32_z(svbool_t_val, svint32_t_val); + svcls_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s64_x(svbool_t_val, svint64_t_val); + svcls_s64_z(svbool_t_val, svint64_t_val); + svcls_x(svbool_t_val, svint8_t_val); + svcls_x(svbool_t_val, svint16_t_val); + svcls_x(svbool_t_val, svint32_t_val); + svcls_x(svbool_t_val, svint64_t_val); + svcls_z(svbool_t_val, svint8_t_val); + svcls_z(svbool_t_val, svint16_t_val); + svcls_z(svbool_t_val, svint32_t_val); + svcls_z(svbool_t_val, svint64_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_s8_x(svbool_t_val, svint8_t_val); + svclz_s8_z(svbool_t_val, svint8_t_val); + svclz_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_s16_x(svbool_t_val, svint16_t_val); + svclz_s16_z(svbool_t_val, svint16_t_val); + svclz_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_s32_x(svbool_t_val, svint32_t_val); + svclz_s32_z(svbool_t_val, svint32_t_val); + svclz_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_s64_x(svbool_t_val, svint64_t_val); + svclz_s64_z(svbool_t_val, svint64_t_val); + svclz_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_u8_x(svbool_t_val, svuint8_t_val); + svclz_u8_z(svbool_t_val, svuint8_t_val); + svclz_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_u16_x(svbool_t_val, svuint16_t_val); + svclz_u16_z(svbool_t_val, svuint16_t_val); + svclz_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_u32_x(svbool_t_val, svuint32_t_val); + svclz_u32_z(svbool_t_val, svuint32_t_val); + svclz_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_u64_x(svbool_t_val, svuint64_t_val); + svclz_u64_z(svbool_t_val, svuint64_t_val); + svclz_x(svbool_t_val, svint8_t_val); + svclz_x(svbool_t_val, svint16_t_val); + svclz_x(svbool_t_val, svint32_t_val); + svclz_x(svbool_t_val, svint64_t_val); + svclz_x(svbool_t_val, svuint8_t_val); + svclz_x(svbool_t_val, svuint16_t_val); + svclz_x(svbool_t_val, svuint32_t_val); + svclz_x(svbool_t_val, svuint64_t_val); + svclz_z(svbool_t_val, svint8_t_val); + svclz_z(svbool_t_val, svint16_t_val); + svclz_z(svbool_t_val, svint32_t_val); + svclz_z(svbool_t_val, svint64_t_val); + svclz_z(svbool_t_val, svuint8_t_val); + svclz_z(svbool_t_val, svuint16_t_val); + svclz_z(svbool_t_val, svuint32_t_val); + svclz_z(svbool_t_val, svuint64_t_val); + svcmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmpeq(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpeq_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple(svbool_t_val, svint8_t_val, int8_t_val); + svcmple(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple(svbool_t_val, svint16_t_val, int16_t_val); + svcmple(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple(svbool_t_val, svint32_t_val, int32_t_val); + svcmple(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple(svbool_t_val, svint64_t_val, int64_t_val); + svcmple(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmple_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmple_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmple_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmple_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpne_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_s8_x(svbool_t_val, svint8_t_val); + svcnot_s8_z(svbool_t_val, svint8_t_val); + svcnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_s16_x(svbool_t_val, svint16_t_val); + svcnot_s16_z(svbool_t_val, svint16_t_val); + svcnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_s32_x(svbool_t_val, svint32_t_val); + svcnot_s32_z(svbool_t_val, svint32_t_val); + svcnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_s64_x(svbool_t_val, svint64_t_val); + svcnot_s64_z(svbool_t_val, svint64_t_val); + svcnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_u8_x(svbool_t_val, svuint8_t_val); + svcnot_u8_z(svbool_t_val, svuint8_t_val); + svcnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_u16_x(svbool_t_val, svuint16_t_val); + svcnot_u16_z(svbool_t_val, svuint16_t_val); + svcnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_u32_x(svbool_t_val, svuint32_t_val); + svcnot_u32_z(svbool_t_val, svuint32_t_val); + svcnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_u64_x(svbool_t_val, svuint64_t_val); + svcnot_u64_z(svbool_t_val, svuint64_t_val); + svcnot_x(svbool_t_val, svint8_t_val); + svcnot_x(svbool_t_val, svint16_t_val); + svcnot_x(svbool_t_val, svint32_t_val); + svcnot_x(svbool_t_val, svint64_t_val); + svcnot_x(svbool_t_val, svuint8_t_val); + svcnot_x(svbool_t_val, svuint16_t_val); + svcnot_x(svbool_t_val, svuint32_t_val); + svcnot_x(svbool_t_val, svuint64_t_val); + svcnot_z(svbool_t_val, svint8_t_val); + svcnot_z(svbool_t_val, svint16_t_val); + svcnot_z(svbool_t_val, svint32_t_val); + svcnot_z(svbool_t_val, svint64_t_val); + svcnot_z(svbool_t_val, svuint8_t_val); + svcnot_z(svbool_t_val, svuint16_t_val); + svcnot_z(svbool_t_val, svuint32_t_val); + svcnot_z(svbool_t_val, svuint64_t_val); + svcnt_bf16_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_bf16_x(svbool_t_val, svbfloat16_t_val); + svcnt_bf16_z(svbool_t_val, svbfloat16_t_val); + svcnt_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_f16_x(svbool_t_val, svfloat16_t_val); + svcnt_f16_z(svbool_t_val, svfloat16_t_val); + svcnt_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_f32_x(svbool_t_val, svfloat32_t_val); + svcnt_f32_z(svbool_t_val, svfloat32_t_val); + svcnt_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_f64_x(svbool_t_val, svfloat64_t_val); + svcnt_f64_z(svbool_t_val, svfloat64_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_s8_x(svbool_t_val, svint8_t_val); + svcnt_s8_z(svbool_t_val, svint8_t_val); + svcnt_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_s16_x(svbool_t_val, svint16_t_val); + svcnt_s16_z(svbool_t_val, svint16_t_val); + svcnt_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_s32_x(svbool_t_val, svint32_t_val); + svcnt_s32_z(svbool_t_val, svint32_t_val); + svcnt_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_s64_x(svbool_t_val, svint64_t_val); + svcnt_s64_z(svbool_t_val, svint64_t_val); + svcnt_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_u8_x(svbool_t_val, svuint8_t_val); + svcnt_u8_z(svbool_t_val, svuint8_t_val); + svcnt_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_u16_x(svbool_t_val, svuint16_t_val); + svcnt_u16_z(svbool_t_val, svuint16_t_val); + svcnt_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_u32_x(svbool_t_val, svuint32_t_val); + svcnt_u32_z(svbool_t_val, svuint32_t_val); + svcnt_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_u64_x(svbool_t_val, svuint64_t_val); + svcnt_u64_z(svbool_t_val, svuint64_t_val); + svcnt_x(svbool_t_val, svbfloat16_t_val); + svcnt_x(svbool_t_val, svfloat16_t_val); + svcnt_x(svbool_t_val, svfloat32_t_val); + svcnt_x(svbool_t_val, svfloat64_t_val); + svcnt_x(svbool_t_val, svint8_t_val); + svcnt_x(svbool_t_val, svint16_t_val); + svcnt_x(svbool_t_val, svint32_t_val); + svcnt_x(svbool_t_val, svint64_t_val); + svcnt_x(svbool_t_val, svuint8_t_val); + svcnt_x(svbool_t_val, svuint16_t_val); + svcnt_x(svbool_t_val, svuint32_t_val); + svcnt_x(svbool_t_val, svuint64_t_val); + svcnt_z(svbool_t_val, svbfloat16_t_val); + svcnt_z(svbool_t_val, svfloat16_t_val); + svcnt_z(svbool_t_val, svfloat32_t_val); + svcnt_z(svbool_t_val, svfloat64_t_val); + svcnt_z(svbool_t_val, svint8_t_val); + svcnt_z(svbool_t_val, svint16_t_val); + svcnt_z(svbool_t_val, svint32_t_val); + svcnt_z(svbool_t_val, svint64_t_val); + svcnt_z(svbool_t_val, svuint8_t_val); + svcnt_z(svbool_t_val, svuint16_t_val); + svcnt_z(svbool_t_val, svuint32_t_val); + svcnt_z(svbool_t_val, svuint64_t_val); + svcntb(); + svcntb_pat(SV_MUL3); + svcntd(); + svcntd_pat(SV_MUL3); + svcnth(); + svcnth_pat(SV_MUL3); + svcntp_b8(svbool_t_val, svbool_t_val); + svcntp_b16(svbool_t_val, svbool_t_val); + svcntp_b32(svbool_t_val, svbool_t_val); + svcntp_b64(svbool_t_val, svbool_t_val); + svcntw(); + svcntw_pat(SV_MUL3); + svcreate2(svbfloat16_t_val, svbfloat16_t_val); + svcreate2(svfloat16_t_val, svfloat16_t_val); + svcreate2(svfloat32_t_val, svfloat32_t_val); + svcreate2(svfloat64_t_val, svfloat64_t_val); + svcreate2(svint8_t_val, svint8_t_val); + svcreate2(svint16_t_val, svint16_t_val); + svcreate2(svint32_t_val, svint32_t_val); + svcreate2(svint64_t_val, svint64_t_val); + svcreate2(svmfloat8_t_val, svmfloat8_t_val); + svcreate2(svuint8_t_val, svuint8_t_val); + svcreate2(svuint16_t_val, svuint16_t_val); + svcreate2(svuint32_t_val, svuint32_t_val); + svcreate2(svuint64_t_val, svuint64_t_val); + svcreate2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svcreate2_f16(svfloat16_t_val, svfloat16_t_val); + svcreate2_f32(svfloat32_t_val, svfloat32_t_val); + svcreate2_f64(svfloat64_t_val, svfloat64_t_val); + svcreate2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svcreate2_s8(svint8_t_val, svint8_t_val); + svcreate2_s16(svint16_t_val, svint16_t_val); + svcreate2_s32(svint32_t_val, svint32_t_val); + svcreate2_s64(svint64_t_val, svint64_t_val); + svcreate2_u8(svuint8_t_val, svuint8_t_val); + svcreate2_u16(svuint16_t_val, svuint16_t_val); + svcreate2_u32(svuint32_t_val, svuint32_t_val); + svcreate2_u64(svuint64_t_val, svuint64_t_val); + svcreate3(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate3_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4_s8(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4_s16(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4_s32(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4_s64(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcvt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_f64_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_s16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_s16_x(svbool_t_val, svint16_t_val); + svcvt_f16_s16_z(svbool_t_val, svint16_t_val); + svcvt_f16_s32_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_s32_x(svbool_t_val, svint32_t_val); + svcvt_f16_s32_z(svbool_t_val, svint32_t_val); + svcvt_f16_s64_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_s64_x(svbool_t_val, svint64_t_val); + svcvt_f16_s64_z(svbool_t_val, svint64_t_val); + svcvt_f16_u16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_u16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_u16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_u32_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f16_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f16_u64_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f16_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f16_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_x(svbool_t_val, svint16_t_val); + svcvt_f16_x(svbool_t_val, svint32_t_val); + svcvt_f16_x(svbool_t_val, svint64_t_val); + svcvt_f16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_x(svbool_t_val, svuint32_t_val); + svcvt_f16_x(svbool_t_val, svuint64_t_val); + svcvt_f16_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_z(svbool_t_val, svint16_t_val); + svcvt_f16_z(svbool_t_val, svint32_t_val); + svcvt_f16_z(svbool_t_val, svint64_t_val); + svcvt_f16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_z(svbool_t_val, svuint32_t_val); + svcvt_f16_z(svbool_t_val, svuint64_t_val); + svcvt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_s32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_s32_x(svbool_t_val, svint32_t_val); + svcvt_f32_s32_z(svbool_t_val, svint32_t_val); + svcvt_f32_s64_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_s64_x(svbool_t_val, svint64_t_val); + svcvt_f32_s64_z(svbool_t_val, svint64_t_val); + svcvt_f32_u32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_u64_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f32_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f32_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_x(svbool_t_val, svint32_t_val); + svcvt_f32_x(svbool_t_val, svint64_t_val); + svcvt_f32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_x(svbool_t_val, svuint64_t_val); + svcvt_f32_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_z(svbool_t_val, svint32_t_val); + svcvt_f32_z(svbool_t_val, svint64_t_val); + svcvt_f32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_z(svbool_t_val, svuint64_t_val); + svcvt_f64_f16_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_s32_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_s32_x(svbool_t_val, svint32_t_val); + svcvt_f64_s32_z(svbool_t_val, svint32_t_val); + svcvt_f64_s64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_s64_x(svbool_t_val, svint64_t_val); + svcvt_f64_s64_z(svbool_t_val, svint64_t_val); + svcvt_f64_u32_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f64_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f64_u64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f64_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_x(svbool_t_val, svint32_t_val); + svcvt_f64_x(svbool_t_val, svint64_t_val); + svcvt_f64_x(svbool_t_val, svuint32_t_val); + svcvt_f64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_z(svbool_t_val, svint32_t_val); + svcvt_f64_z(svbool_t_val, svint64_t_val); + svcvt_f64_z(svbool_t_val, svuint32_t_val); + svcvt_f64_z(svbool_t_val, svuint64_t_val); + svcvt_s16_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_f64_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_f16_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_f32_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_z(svbool_t_val, svfloat64_t_val); + svcvt_u16_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_f64_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_f16_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_f32_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_z(svbool_t_val, svfloat64_t_val); + svdiv_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdot(svint32_t_val, svint8_t_val, int8_t_val); + svdot(svint32_t_val, svint8_t_val, svint8_t_val); + svdot(svint64_t_val, svint16_t_val, int16_t_val); + svdot(svint64_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdot(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_n_s32(svint32_t_val, svint8_t_val, int8_t_val); + svdot_n_s64(svint64_t_val, svint16_t_val, int16_t_val); + svdot_n_u32(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot_n_u64(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_s32(svint32_t_val, svint8_t_val, svint8_t_val); + svdot_s64(svint64_t_val, svint16_t_val, svint16_t_val); + svdot_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdup_b8(bool_val); + svdup_b16(bool_val); + svdup_b32(bool_val); + svdup_b64(bool_val); + svdup_bf16(bfloat16_t_val); + svdup_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_f16(float16_t_val); + svdup_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_f16_x(svbool_t_val, float16_t_val); + svdup_f16_z(svbool_t_val, float16_t_val); + svdup_f32(float32_t_val); + svdup_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_f32_x(svbool_t_val, float32_t_val); + svdup_f32_z(svbool_t_val, float32_t_val); + svdup_f64(float64_t_val); + svdup_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_f64_x(svbool_t_val, float64_t_val); + svdup_f64_z(svbool_t_val, float64_t_val); + svdup_lane(svbfloat16_t_val, uint16_t_val); + svdup_lane(svfloat16_t_val, uint16_t_val); + svdup_lane(svfloat32_t_val, uint32_t_val); + svdup_lane(svfloat64_t_val, uint64_t_val); + svdup_lane(svint8_t_val, uint8_t_val); + svdup_lane(svint16_t_val, uint16_t_val); + svdup_lane(svint32_t_val, uint32_t_val); + svdup_lane(svint64_t_val, uint64_t_val); + svdup_lane(svuint8_t_val, uint8_t_val); + svdup_lane(svuint16_t_val, uint16_t_val); + svdup_lane(svuint32_t_val, uint32_t_val); + svdup_lane(svuint64_t_val, uint64_t_val); + svdup_lane_bf16(svbfloat16_t_val, uint16_t_val); + svdup_lane_f16(svfloat16_t_val, uint16_t_val); + svdup_lane_f32(svfloat32_t_val, uint32_t_val); + svdup_lane_f64(svfloat64_t_val, uint64_t_val); + svdup_lane_s8(svint8_t_val, uint8_t_val); + svdup_lane_s16(svint16_t_val, uint16_t_val); + svdup_lane_s32(svint32_t_val, uint32_t_val); + svdup_lane_s64(svint64_t_val, uint64_t_val); + svdup_lane_u8(svuint8_t_val, uint8_t_val); + svdup_lane_u16(svuint16_t_val, uint16_t_val); + svdup_lane_u32(svuint32_t_val, uint32_t_val); + svdup_lane_u64(svuint64_t_val, uint64_t_val); + svdup_n_b8(bool_val); + svdup_n_b16(bool_val); + svdup_n_b32(bool_val); + svdup_n_b64(bool_val); + svdup_n_bf16(bfloat16_t_val); + svdup_n_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_n_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_n_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_n_f16(float16_t_val); + svdup_n_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_n_f16_x(svbool_t_val, float16_t_val); + svdup_n_f16_z(svbool_t_val, float16_t_val); + svdup_n_f32(float32_t_val); + svdup_n_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_n_f32_x(svbool_t_val, float32_t_val); + svdup_n_f32_z(svbool_t_val, float32_t_val); + svdup_n_f64(float64_t_val); + svdup_n_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_n_f64_x(svbool_t_val, float64_t_val); + svdup_n_f64_z(svbool_t_val, float64_t_val); + svdup_n_s8(int8_t_val); + svdup_n_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_n_s8_x(svbool_t_val, int8_t_val); + svdup_n_s8_z(svbool_t_val, int8_t_val); + svdup_n_s16(int16_t_val); + svdup_n_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_n_s16_x(svbool_t_val, int16_t_val); + svdup_n_s16_z(svbool_t_val, int16_t_val); + svdup_n_s32(int32_t_val); + svdup_n_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_n_s32_x(svbool_t_val, int32_t_val); + svdup_n_s32_z(svbool_t_val, int32_t_val); + svdup_n_s64(int64_t_val); + svdup_n_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_n_s64_x(svbool_t_val, int64_t_val); + svdup_n_s64_z(svbool_t_val, int64_t_val); + svdup_n_u8(uint8_t_val); + svdup_n_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_n_u8_x(svbool_t_val, uint8_t_val); + svdup_n_u8_z(svbool_t_val, uint8_t_val); + svdup_n_u16(uint16_t_val); + svdup_n_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_n_u16_x(svbool_t_val, uint16_t_val); + svdup_n_u16_z(svbool_t_val, uint16_t_val); + svdup_n_u32(uint32_t_val); + svdup_n_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_n_u32_x(svbool_t_val, uint32_t_val); + svdup_n_u32_z(svbool_t_val, uint32_t_val); + svdup_n_u64(uint64_t_val); + svdup_n_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_n_u64_x(svbool_t_val, uint64_t_val); + svdup_n_u64_z(svbool_t_val, uint64_t_val); + svdup_s8(int8_t_val); + svdup_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_s8_x(svbool_t_val, int8_t_val); + svdup_s8_z(svbool_t_val, int8_t_val); + svdup_s16(int16_t_val); + svdup_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_s16_x(svbool_t_val, int16_t_val); + svdup_s16_z(svbool_t_val, int16_t_val); + svdup_s32(int32_t_val); + svdup_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_s32_x(svbool_t_val, int32_t_val); + svdup_s32_z(svbool_t_val, int32_t_val); + svdup_s64(int64_t_val); + svdup_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_s64_x(svbool_t_val, int64_t_val); + svdup_s64_z(svbool_t_val, int64_t_val); + svdup_u8(uint8_t_val); + svdup_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_u8_x(svbool_t_val, uint8_t_val); + svdup_u8_z(svbool_t_val, uint8_t_val); + svdup_u16(uint16_t_val); + svdup_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_u16_x(svbool_t_val, uint16_t_val); + svdup_u16_z(svbool_t_val, uint16_t_val); + svdup_u32(uint32_t_val); + svdup_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_u32_x(svbool_t_val, uint32_t_val); + svdup_u32_z(svbool_t_val, uint32_t_val); + svdup_u64(uint64_t_val); + svdup_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_u64_x(svbool_t_val, uint64_t_val); + svdup_u64_z(svbool_t_val, uint64_t_val); + svdupq_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_b64(bool_val, bool_val); + svdupq_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_f64(float64_t_val, float64_t_val); + svdupq_lane(svbfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat32_t_val, uint64_t_val); + svdupq_lane(svfloat64_t_val, uint64_t_val); + svdupq_lane(svint8_t_val, uint64_t_val); + svdupq_lane(svint16_t_val, uint64_t_val); + svdupq_lane(svint32_t_val, uint64_t_val); + svdupq_lane(svint64_t_val, uint64_t_val); + svdupq_lane(svuint8_t_val, uint64_t_val); + svdupq_lane(svuint16_t_val, uint64_t_val); + svdupq_lane(svuint32_t_val, uint64_t_val); + svdupq_lane(svuint64_t_val, uint64_t_val); + svdupq_lane_bf16(svbfloat16_t_val, uint64_t_val); + svdupq_lane_f16(svfloat16_t_val, uint64_t_val); + svdupq_lane_f32(svfloat32_t_val, uint64_t_val); + svdupq_lane_f64(svfloat64_t_val, uint64_t_val); + svdupq_lane_s8(svint8_t_val, uint64_t_val); + svdupq_lane_s16(svint16_t_val, uint64_t_val); + svdupq_lane_s32(svint32_t_val, uint64_t_val); + svdupq_lane_s64(svint64_t_val, uint64_t_val); + svdupq_lane_u8(svuint8_t_val, uint64_t_val); + svdupq_lane_u16(svuint16_t_val, uint64_t_val); + svdupq_lane_u32(svuint32_t_val, uint64_t_val); + svdupq_lane_u64(svuint64_t_val, uint64_t_val); + svdupq_n_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_n_b64(bool_val, bool_val); + svdupq_n_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_n_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_n_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_n_f64(float64_t_val, float64_t_val); + svdupq_n_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_n_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_n_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_n_s64(int64_t_val, int64_t_val); + svdupq_n_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_n_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_n_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_n_u64(uint64_t_val, uint64_t_val); + svdupq_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_s64(int64_t_val, int64_t_val); + svdupq_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_u64(uint64_t_val, uint64_t_val); + sveor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveorv(svbool_t_val, svint8_t_val); + sveorv(svbool_t_val, svint16_t_val); + sveorv(svbool_t_val, svint32_t_val); + sveorv(svbool_t_val, svint64_t_val); + sveorv(svbool_t_val, svuint8_t_val); + sveorv(svbool_t_val, svuint16_t_val); + sveorv(svbool_t_val, svuint32_t_val); + sveorv(svbool_t_val, svuint64_t_val); + sveorv_s8(svbool_t_val, svint8_t_val); + sveorv_s16(svbool_t_val, svint16_t_val); + sveorv_s32(svbool_t_val, svint32_t_val); + sveorv_s64(svbool_t_val, svint64_t_val); + sveorv_u8(svbool_t_val, svuint8_t_val); + sveorv_u16(svbool_t_val, svuint16_t_val); + sveorv_u32(svbool_t_val, svuint32_t_val); + sveorv_u64(svbool_t_val, svuint64_t_val); + svext(svbfloat16_t_val, svbfloat16_t_val, 2); + svext(svfloat16_t_val, svfloat16_t_val, 2); + svext(svfloat32_t_val, svfloat32_t_val, 2); + svext(svfloat64_t_val, svfloat64_t_val, 2); + svext(svint8_t_val, svint8_t_val, 2); + svext(svint16_t_val, svint16_t_val, 2); + svext(svint32_t_val, svint32_t_val, 2); + svext(svint64_t_val, svint64_t_val, 2); + svext(svuint8_t_val, svuint8_t_val, 2); + svext(svuint16_t_val, svuint16_t_val, 2); + svext(svuint32_t_val, svuint32_t_val, 2); + svext(svuint64_t_val, svuint64_t_val, 2); + svext_bf16(svbfloat16_t_val, svbfloat16_t_val, 2); + svext_f16(svfloat16_t_val, svfloat16_t_val, 2); + svext_f32(svfloat32_t_val, svfloat32_t_val, 2); + svext_f64(svfloat64_t_val, svfloat64_t_val, 2); + svext_s8(svint8_t_val, svint8_t_val, 2); + svext_s16(svint16_t_val, svint16_t_val, 2); + svext_s32(svint32_t_val, svint32_t_val, 2); + svext_s64(svint64_t_val, svint64_t_val, 2); + svext_u8(svuint8_t_val, svuint8_t_val, 2); + svext_u16(svuint16_t_val, svuint16_t_val, 2); + svext_u32(svuint32_t_val, svuint32_t_val, 2); + svext_u64(svuint64_t_val, svuint64_t_val, 2); + svextb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_s16_x(svbool_t_val, svint16_t_val); + svextb_s16_z(svbool_t_val, svint16_t_val); + svextb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_s32_x(svbool_t_val, svint32_t_val); + svextb_s32_z(svbool_t_val, svint32_t_val); + svextb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_s64_x(svbool_t_val, svint64_t_val); + svextb_s64_z(svbool_t_val, svint64_t_val); + svextb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_u16_x(svbool_t_val, svuint16_t_val); + svextb_u16_z(svbool_t_val, svuint16_t_val); + svextb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_u32_x(svbool_t_val, svuint32_t_val); + svextb_u32_z(svbool_t_val, svuint32_t_val); + svextb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_u64_x(svbool_t_val, svuint64_t_val); + svextb_u64_z(svbool_t_val, svuint64_t_val); + svextb_x(svbool_t_val, svint16_t_val); + svextb_x(svbool_t_val, svint32_t_val); + svextb_x(svbool_t_val, svint64_t_val); + svextb_x(svbool_t_val, svuint16_t_val); + svextb_x(svbool_t_val, svuint32_t_val); + svextb_x(svbool_t_val, svuint64_t_val); + svextb_z(svbool_t_val, svint16_t_val); + svextb_z(svbool_t_val, svint32_t_val); + svextb_z(svbool_t_val, svint64_t_val); + svextb_z(svbool_t_val, svuint16_t_val); + svextb_z(svbool_t_val, svuint32_t_val); + svextb_z(svbool_t_val, svuint64_t_val); + svexth_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_s32_x(svbool_t_val, svint32_t_val); + svexth_s32_z(svbool_t_val, svint32_t_val); + svexth_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_s64_x(svbool_t_val, svint64_t_val); + svexth_s64_z(svbool_t_val, svint64_t_val); + svexth_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_u32_x(svbool_t_val, svuint32_t_val); + svexth_u32_z(svbool_t_val, svuint32_t_val); + svexth_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_u64_x(svbool_t_val, svuint64_t_val); + svexth_u64_z(svbool_t_val, svuint64_t_val); + svexth_x(svbool_t_val, svint32_t_val); + svexth_x(svbool_t_val, svint64_t_val); + svexth_x(svbool_t_val, svuint32_t_val); + svexth_x(svbool_t_val, svuint64_t_val); + svexth_z(svbool_t_val, svint32_t_val); + svexth_z(svbool_t_val, svint64_t_val); + svexth_z(svbool_t_val, svuint32_t_val); + svexth_z(svbool_t_val, svuint64_t_val); + svextw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_s64_x(svbool_t_val, svint64_t_val); + svextw_s64_z(svbool_t_val, svint64_t_val); + svextw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_u64_x(svbool_t_val, svuint64_t_val); + svextw_u64_z(svbool_t_val, svuint64_t_val); + svextw_x(svbool_t_val, svint64_t_val); + svextw_x(svbool_t_val, svuint64_t_val); + svextw_z(svbool_t_val, svint64_t_val); + svextw_z(svbool_t_val, svuint64_t_val); + svget2(svbfloat16x2_t_val, 1); + svget2(svfloat16x2_t_val, 1); + svget2(svfloat32x2_t_val, 1); + svget2(svfloat64x2_t_val, 1); + svget2(svint8x2_t_val, 1); + svget2(svint16x2_t_val, 1); + svget2(svint32x2_t_val, 1); + svget2(svint64x2_t_val, 1); + svget2(svmfloat8x2_t_val, 1); + svget2(svuint8x2_t_val, 1); + svget2(svuint16x2_t_val, 1); + svget2(svuint32x2_t_val, 1); + svget2(svuint64x2_t_val, 1); + svget2_bf16(svbfloat16x2_t_val, 1); + svget2_f16(svfloat16x2_t_val, 1); + svget2_f32(svfloat32x2_t_val, 1); + svget2_f64(svfloat64x2_t_val, 1); + svget2_mf8(svmfloat8x2_t_val, 1); + svget2_s8(svint8x2_t_val, 1); + svget2_s16(svint16x2_t_val, 1); + svget2_s32(svint32x2_t_val, 1); + svget2_s64(svint64x2_t_val, 1); + svget2_u8(svuint8x2_t_val, 1); + svget2_u16(svuint16x2_t_val, 1); + svget2_u32(svuint32x2_t_val, 1); + svget2_u64(svuint64x2_t_val, 1); + svget3(svbfloat16x3_t_val, 2); + svget3(svfloat16x3_t_val, 2); + svget3(svfloat32x3_t_val, 2); + svget3(svfloat64x3_t_val, 2); + svget3(svint8x3_t_val, 2); + svget3(svint16x3_t_val, 2); + svget3(svint32x3_t_val, 2); + svget3(svint64x3_t_val, 2); + svget3(svmfloat8x3_t_val, 2); + svget3(svuint8x3_t_val, 2); + svget3(svuint16x3_t_val, 2); + svget3(svuint32x3_t_val, 2); + svget3(svuint64x3_t_val, 2); + svget3_bf16(svbfloat16x3_t_val, 2); + svget3_f16(svfloat16x3_t_val, 2); + svget3_f32(svfloat32x3_t_val, 2); + svget3_f64(svfloat64x3_t_val, 2); + svget3_mf8(svmfloat8x3_t_val, 2); + svget3_s8(svint8x3_t_val, 2); + svget3_s16(svint16x3_t_val, 2); + svget3_s32(svint32x3_t_val, 2); + svget3_s64(svint64x3_t_val, 2); + svget3_u8(svuint8x3_t_val, 2); + svget3_u16(svuint16x3_t_val, 2); + svget3_u32(svuint32x3_t_val, 2); + svget3_u64(svuint64x3_t_val, 2); + svget4(svbfloat16x4_t_val, 2); + svget4(svfloat16x4_t_val, 2); + svget4(svfloat32x4_t_val, 2); + svget4(svfloat64x4_t_val, 2); + svget4(svint8x4_t_val, 2); + svget4(svint16x4_t_val, 2); + svget4(svint32x4_t_val, 2); + svget4(svint64x4_t_val, 2); + svget4(svmfloat8x4_t_val, 2); + svget4(svuint8x4_t_val, 2); + svget4(svuint16x4_t_val, 2); + svget4(svuint32x4_t_val, 2); + svget4(svuint64x4_t_val, 2); + svget4_bf16(svbfloat16x4_t_val, 2); + svget4_f16(svfloat16x4_t_val, 2); + svget4_f32(svfloat32x4_t_val, 2); + svget4_f64(svfloat64x4_t_val, 2); + svget4_mf8(svmfloat8x4_t_val, 2); + svget4_s8(svint8x4_t_val, 2); + svget4_s16(svint16x4_t_val, 2); + svget4_s32(svint32x4_t_val, 2); + svget4_s64(svint64x4_t_val, 2); + svget4_u8(svuint8x4_t_val, 2); + svget4_u16(svuint16x4_t_val, 2); + svget4_u32(svuint32x4_t_val, 2); + svget4_u64(svuint64x4_t_val, 2); + svindex_s8(int8_t_val, int8_t_val); + svindex_s16(int16_t_val, int16_t_val); + svindex_s32(int32_t_val, int32_t_val); + svindex_s64(int64_t_val, int64_t_val); + svindex_u8(uint8_t_val, uint8_t_val); + svindex_u16(uint16_t_val, uint16_t_val); + svindex_u32(uint32_t_val, uint32_t_val); + svindex_u64(uint64_t_val, uint64_t_val); + svinsr(svbfloat16_t_val, bfloat16_t_val); + svinsr(svfloat16_t_val, float16_t_val); + svinsr(svfloat32_t_val, float32_t_val); + svinsr(svfloat64_t_val, float64_t_val); + svinsr(svint8_t_val, int8_t_val); + svinsr(svint16_t_val, int16_t_val); + svinsr(svint32_t_val, int32_t_val); + svinsr(svint64_t_val, int64_t_val); + svinsr(svuint8_t_val, uint8_t_val); + svinsr(svuint16_t_val, uint16_t_val); + svinsr(svuint32_t_val, uint32_t_val); + svinsr(svuint64_t_val, uint64_t_val); + svinsr_n_bf16(svbfloat16_t_val, bfloat16_t_val); + svinsr_n_f16(svfloat16_t_val, float16_t_val); + svinsr_n_f32(svfloat32_t_val, float32_t_val); + svinsr_n_f64(svfloat64_t_val, float64_t_val); + svinsr_n_s8(svint8_t_val, int8_t_val); + svinsr_n_s16(svint16_t_val, int16_t_val); + svinsr_n_s32(svint32_t_val, int32_t_val); + svinsr_n_s64(svint64_t_val, int64_t_val); + svinsr_n_u8(svuint8_t_val, uint8_t_val); + svinsr_n_u16(svuint16_t_val, uint16_t_val); + svinsr_n_u32(svuint32_t_val, uint32_t_val); + svinsr_n_u64(svuint64_t_val, uint64_t_val); + svlasta(svbool_t_val, svbfloat16_t_val); + svlasta(svbool_t_val, svfloat16_t_val); + svlasta(svbool_t_val, svfloat32_t_val); + svlasta(svbool_t_val, svfloat64_t_val); + svlasta(svbool_t_val, svint8_t_val); + svlasta(svbool_t_val, svint16_t_val); + svlasta(svbool_t_val, svint32_t_val); + svlasta(svbool_t_val, svint64_t_val); + svlasta(svbool_t_val, svuint8_t_val); + svlasta(svbool_t_val, svuint16_t_val); + svlasta(svbool_t_val, svuint32_t_val); + svlasta(svbool_t_val, svuint64_t_val); + svlasta_bf16(svbool_t_val, svbfloat16_t_val); + svlasta_f16(svbool_t_val, svfloat16_t_val); + svlasta_f32(svbool_t_val, svfloat32_t_val); + svlasta_f64(svbool_t_val, svfloat64_t_val); + svlasta_s8(svbool_t_val, svint8_t_val); + svlasta_s16(svbool_t_val, svint16_t_val); + svlasta_s32(svbool_t_val, svint32_t_val); + svlasta_s64(svbool_t_val, svint64_t_val); + svlasta_u8(svbool_t_val, svuint8_t_val); + svlasta_u16(svbool_t_val, svuint16_t_val); + svlasta_u32(svbool_t_val, svuint32_t_val); + svlasta_u64(svbool_t_val, svuint64_t_val); + svlastb(svbool_t_val, svbfloat16_t_val); + svlastb(svbool_t_val, svfloat16_t_val); + svlastb(svbool_t_val, svfloat32_t_val); + svlastb(svbool_t_val, svfloat64_t_val); + svlastb(svbool_t_val, svint8_t_val); + svlastb(svbool_t_val, svint16_t_val); + svlastb(svbool_t_val, svint32_t_val); + svlastb(svbool_t_val, svint64_t_val); + svlastb(svbool_t_val, svuint8_t_val); + svlastb(svbool_t_val, svuint16_t_val); + svlastb(svbool_t_val, svuint32_t_val); + svlastb(svbool_t_val, svuint64_t_val); + svlastb_bf16(svbool_t_val, svbfloat16_t_val); + svlastb_f16(svbool_t_val, svfloat16_t_val); + svlastb_f32(svbool_t_val, svfloat32_t_val); + svlastb_f64(svbool_t_val, svfloat64_t_val); + svlastb_s8(svbool_t_val, svint8_t_val); + svlastb_s16(svbool_t_val, svint16_t_val); + svlastb_s32(svbool_t_val, svint32_t_val); + svlastb_s64(svbool_t_val, svint64_t_val); + svlastb_u8(svbool_t_val, svuint8_t_val); + svlastb_u16(svbool_t_val, svuint16_t_val); + svlastb_u32(svbool_t_val, svuint32_t_val); + svlastb_u64(svbool_t_val, svuint64_t_val); + svld1(svbool_t_val, bfloat16_t_ptr_val); + svld1(svbool_t_val, float16_t_ptr_val); + svld1(svbool_t_val, float32_t_ptr_val); + svld1(svbool_t_val, float64_t_ptr_val); + svld1(svbool_t_val, int8_t_ptr_val); + svld1(svbool_t_val, int16_t_ptr_val); + svld1(svbool_t_val, int32_t_ptr_val); + svld1(svbool_t_val, int64_t_ptr_val); + svld1(svbool_t_val, mfloat8_t_ptr_val); + svld1(svbool_t_val, uint8_t_ptr_val); + svld1(svbool_t_val, uint16_t_ptr_val); + svld1(svbool_t_val, uint32_t_ptr_val); + svld1(svbool_t_val, uint64_t_ptr_val); + svld1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1_f16(svbool_t_val, float16_t_ptr_val); + svld1_f32(svbool_t_val, float32_t_ptr_val); + svld1_f64(svbool_t_val, float64_t_ptr_val); + svld1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1_s8(svbool_t_val, int8_t_ptr_val); + svld1_s16(svbool_t_val, int16_t_ptr_val); + svld1_s32(svbool_t_val, int32_t_ptr_val); + svld1_s64(svbool_t_val, int64_t_ptr_val); + svld1_u8(svbool_t_val, uint8_t_ptr_val); + svld1_u16(svbool_t_val, uint16_t_ptr_val); + svld1_u32(svbool_t_val, uint32_t_ptr_val); + svld1_u64(svbool_t_val, uint64_t_ptr_val); + svld1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1rq(svbool_t_val, bfloat16_t_ptr_val); + svld1rq(svbool_t_val, float16_t_ptr_val); + svld1rq(svbool_t_val, float32_t_ptr_val); + svld1rq(svbool_t_val, float64_t_ptr_val); + svld1rq(svbool_t_val, int8_t_ptr_val); + svld1rq(svbool_t_val, int16_t_ptr_val); + svld1rq(svbool_t_val, int32_t_ptr_val); + svld1rq(svbool_t_val, int64_t_ptr_val); + svld1rq(svbool_t_val, mfloat8_t_ptr_val); + svld1rq(svbool_t_val, uint8_t_ptr_val); + svld1rq(svbool_t_val, uint16_t_ptr_val); + svld1rq(svbool_t_val, uint32_t_ptr_val); + svld1rq(svbool_t_val, uint64_t_ptr_val); + svld1rq_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1rq_f16(svbool_t_val, float16_t_ptr_val); + svld1rq_f32(svbool_t_val, float32_t_ptr_val); + svld1rq_f64(svbool_t_val, float64_t_ptr_val); + svld1rq_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1rq_s8(svbool_t_val, int8_t_ptr_val); + svld1rq_s16(svbool_t_val, int16_t_ptr_val); + svld1rq_s32(svbool_t_val, int32_t_ptr_val); + svld1rq_s64(svbool_t_val, int64_t_ptr_val); + svld1rq_u8(svbool_t_val, uint8_t_ptr_val); + svld1rq_u16(svbool_t_val, uint16_t_ptr_val); + svld1rq_u32(svbool_t_val, uint32_t_ptr_val); + svld1rq_u64(svbool_t_val, uint64_t_ptr_val); + svld1sb_s16(svbool_t_val, int8_t_ptr_val); + svld1sb_s32(svbool_t_val, int8_t_ptr_val); + svld1sb_s64(svbool_t_val, int8_t_ptr_val); + svld1sb_u16(svbool_t_val, int8_t_ptr_val); + svld1sb_u32(svbool_t_val, int8_t_ptr_val); + svld1sb_u64(svbool_t_val, int8_t_ptr_val); + svld1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sh_s32(svbool_t_val, int16_t_ptr_val); + svld1sh_s64(svbool_t_val, int16_t_ptr_val); + svld1sh_u32(svbool_t_val, int16_t_ptr_val); + svld1sh_u64(svbool_t_val, int16_t_ptr_val); + svld1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sw_s64(svbool_t_val, int32_t_ptr_val); + svld1sw_u64(svbool_t_val, int32_t_ptr_val); + svld1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1ub_s16(svbool_t_val, uint8_t_ptr_val); + svld1ub_s32(svbool_t_val, uint8_t_ptr_val); + svld1ub_s64(svbool_t_val, uint8_t_ptr_val); + svld1ub_u16(svbool_t_val, uint8_t_ptr_val); + svld1ub_u32(svbool_t_val, uint8_t_ptr_val); + svld1ub_u64(svbool_t_val, uint8_t_ptr_val); + svld1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1uh_s32(svbool_t_val, uint16_t_ptr_val); + svld1uh_s64(svbool_t_val, uint16_t_ptr_val); + svld1uh_u32(svbool_t_val, uint16_t_ptr_val); + svld1uh_u64(svbool_t_val, uint16_t_ptr_val); + svld1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uw_s64(svbool_t_val, uint32_t_ptr_val); + svld1uw_u64(svbool_t_val, uint32_t_ptr_val); + svld1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2(svbool_t_val, bfloat16_t_ptr_val); + svld2(svbool_t_val, float16_t_ptr_val); + svld2(svbool_t_val, float32_t_ptr_val); + svld2(svbool_t_val, float64_t_ptr_val); + svld2(svbool_t_val, int8_t_ptr_val); + svld2(svbool_t_val, int16_t_ptr_val); + svld2(svbool_t_val, int32_t_ptr_val); + svld2(svbool_t_val, int64_t_ptr_val); + svld2(svbool_t_val, mfloat8_t_ptr_val); + svld2(svbool_t_val, uint8_t_ptr_val); + svld2(svbool_t_val, uint16_t_ptr_val); + svld2(svbool_t_val, uint32_t_ptr_val); + svld2(svbool_t_val, uint64_t_ptr_val); + svld2_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2_f16(svbool_t_val, float16_t_ptr_val); + svld2_f32(svbool_t_val, float32_t_ptr_val); + svld2_f64(svbool_t_val, float64_t_ptr_val); + svld2_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2_s8(svbool_t_val, int8_t_ptr_val); + svld2_s16(svbool_t_val, int16_t_ptr_val); + svld2_s32(svbool_t_val, int32_t_ptr_val); + svld2_s64(svbool_t_val, int64_t_ptr_val); + svld2_u8(svbool_t_val, uint8_t_ptr_val); + svld2_u16(svbool_t_val, uint16_t_ptr_val); + svld2_u32(svbool_t_val, uint32_t_ptr_val); + svld2_u64(svbool_t_val, uint64_t_ptr_val); + svld2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3(svbool_t_val, bfloat16_t_ptr_val); + svld3(svbool_t_val, float16_t_ptr_val); + svld3(svbool_t_val, float32_t_ptr_val); + svld3(svbool_t_val, float64_t_ptr_val); + svld3(svbool_t_val, int8_t_ptr_val); + svld3(svbool_t_val, int16_t_ptr_val); + svld3(svbool_t_val, int32_t_ptr_val); + svld3(svbool_t_val, int64_t_ptr_val); + svld3(svbool_t_val, mfloat8_t_ptr_val); + svld3(svbool_t_val, uint8_t_ptr_val); + svld3(svbool_t_val, uint16_t_ptr_val); + svld3(svbool_t_val, uint32_t_ptr_val); + svld3(svbool_t_val, uint64_t_ptr_val); + svld3_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3_f16(svbool_t_val, float16_t_ptr_val); + svld3_f32(svbool_t_val, float32_t_ptr_val); + svld3_f64(svbool_t_val, float64_t_ptr_val); + svld3_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3_s8(svbool_t_val, int8_t_ptr_val); + svld3_s16(svbool_t_val, int16_t_ptr_val); + svld3_s32(svbool_t_val, int32_t_ptr_val); + svld3_s64(svbool_t_val, int64_t_ptr_val); + svld3_u8(svbool_t_val, uint8_t_ptr_val); + svld3_u16(svbool_t_val, uint16_t_ptr_val); + svld3_u32(svbool_t_val, uint32_t_ptr_val); + svld3_u64(svbool_t_val, uint64_t_ptr_val); + svld3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4(svbool_t_val, bfloat16_t_ptr_val); + svld4(svbool_t_val, float16_t_ptr_val); + svld4(svbool_t_val, float32_t_ptr_val); + svld4(svbool_t_val, float64_t_ptr_val); + svld4(svbool_t_val, int8_t_ptr_val); + svld4(svbool_t_val, int16_t_ptr_val); + svld4(svbool_t_val, int32_t_ptr_val); + svld4(svbool_t_val, int64_t_ptr_val); + svld4(svbool_t_val, mfloat8_t_ptr_val); + svld4(svbool_t_val, uint8_t_ptr_val); + svld4(svbool_t_val, uint16_t_ptr_val); + svld4(svbool_t_val, uint32_t_ptr_val); + svld4(svbool_t_val, uint64_t_ptr_val); + svld4_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4_f16(svbool_t_val, float16_t_ptr_val); + svld4_f32(svbool_t_val, float32_t_ptr_val); + svld4_f64(svbool_t_val, float64_t_ptr_val); + svld4_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4_s8(svbool_t_val, int8_t_ptr_val); + svld4_s16(svbool_t_val, int16_t_ptr_val); + svld4_s32(svbool_t_val, int32_t_ptr_val); + svld4_s64(svbool_t_val, int64_t_ptr_val); + svld4_u8(svbool_t_val, uint8_t_ptr_val); + svld4_u16(svbool_t_val, uint16_t_ptr_val); + svld4_u32(svbool_t_val, uint32_t_ptr_val); + svld4_u64(svbool_t_val, uint64_t_ptr_val); + svld4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1(svbool_t_val, bfloat16_t_ptr_val); + svldnt1(svbool_t_val, float16_t_ptr_val); + svldnt1(svbool_t_val, float32_t_ptr_val); + svldnt1(svbool_t_val, float64_t_ptr_val); + svldnt1(svbool_t_val, int8_t_ptr_val); + svldnt1(svbool_t_val, int16_t_ptr_val); + svldnt1(svbool_t_val, int32_t_ptr_val); + svldnt1(svbool_t_val, int64_t_ptr_val); + svldnt1(svbool_t_val, mfloat8_t_ptr_val); + svldnt1(svbool_t_val, uint8_t_ptr_val); + svldnt1(svbool_t_val, uint16_t_ptr_val); + svldnt1(svbool_t_val, uint32_t_ptr_val); + svldnt1(svbool_t_val, uint64_t_ptr_val); + svldnt1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svldnt1_f16(svbool_t_val, float16_t_ptr_val); + svldnt1_f32(svbool_t_val, float32_t_ptr_val); + svldnt1_f64(svbool_t_val, float64_t_ptr_val); + svldnt1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svldnt1_s8(svbool_t_val, int8_t_ptr_val); + svldnt1_s16(svbool_t_val, int16_t_ptr_val); + svldnt1_s32(svbool_t_val, int32_t_ptr_val); + svldnt1_s64(svbool_t_val, int64_t_ptr_val); + svldnt1_u8(svbool_t_val, uint8_t_ptr_val); + svldnt1_u16(svbool_t_val, uint16_t_ptr_val); + svldnt1_u32(svbool_t_val, uint32_t_ptr_val); + svldnt1_u64(svbool_t_val, uint64_t_ptr_val); + svldnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svlen(svbfloat16_t_val); + svlen(svfloat16_t_val); + svlen(svfloat32_t_val); + svlen(svfloat64_t_val); + svlen(svint8_t_val); + svlen(svint16_t_val); + svlen(svint32_t_val); + svlen(svint64_t_val); + svlen(svuint8_t_val); + svlen(svuint16_t_val); + svlen(svuint32_t_val); + svlen(svuint64_t_val); + svlen_bf16(svbfloat16_t_val); + svlen_f16(svfloat16_t_val); + svlen_f32(svfloat32_t_val); + svlen_f64(svfloat64_t_val); + svlen_s8(svint8_t_val); + svlen_s16(svint16_t_val); + svlen_s32(svint32_t_val); + svlen_s64(svint64_t_val); + svlen_u8(svuint8_t_val); + svlen_u16(svuint16_t_val); + svlen_u32(svuint32_t_val); + svlen_u64(svuint64_t_val); + svlsl_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmaxnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmv(svbool_t_val, svfloat16_t_val); + svmaxnmv(svbool_t_val, svfloat32_t_val); + svmaxnmv(svbool_t_val, svfloat64_t_val); + svmaxnmv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmv_f64(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svfloat16_t_val); + svmaxv(svbool_t_val, svfloat32_t_val); + svmaxv(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svint8_t_val); + svmaxv(svbool_t_val, svint16_t_val); + svmaxv(svbool_t_val, svint32_t_val); + svmaxv(svbool_t_val, svint64_t_val); + svmaxv(svbool_t_val, svuint8_t_val); + svmaxv(svbool_t_val, svuint16_t_val); + svmaxv(svbool_t_val, svuint32_t_val); + svmaxv(svbool_t_val, svuint64_t_val); + svmaxv_f16(svbool_t_val, svfloat16_t_val); + svmaxv_f32(svbool_t_val, svfloat32_t_val); + svmaxv_f64(svbool_t_val, svfloat64_t_val); + svmaxv_s8(svbool_t_val, svint8_t_val); + svmaxv_s16(svbool_t_val, svint16_t_val); + svmaxv_s32(svbool_t_val, svint32_t_val); + svmaxv_s64(svbool_t_val, svint64_t_val); + svmaxv_u8(svbool_t_val, svuint8_t_val); + svmaxv_u16(svbool_t_val, svuint16_t_val); + svmaxv_u32(svbool_t_val, svuint32_t_val); + svmaxv_u64(svbool_t_val, svuint64_t_val); + svmin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svminnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmv(svbool_t_val, svfloat16_t_val); + svminnmv(svbool_t_val, svfloat32_t_val); + svminnmv(svbool_t_val, svfloat64_t_val); + svminnmv_f16(svbool_t_val, svfloat16_t_val); + svminnmv_f32(svbool_t_val, svfloat32_t_val); + svminnmv_f64(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svfloat16_t_val); + svminv(svbool_t_val, svfloat32_t_val); + svminv(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svint8_t_val); + svminv(svbool_t_val, svint16_t_val); + svminv(svbool_t_val, svint32_t_val); + svminv(svbool_t_val, svint64_t_val); + svminv(svbool_t_val, svuint8_t_val); + svminv(svbool_t_val, svuint16_t_val); + svminv(svbool_t_val, svuint32_t_val); + svminv(svbool_t_val, svuint64_t_val); + svminv_f16(svbool_t_val, svfloat16_t_val); + svminv_f32(svbool_t_val, svfloat32_t_val); + svminv_f64(svbool_t_val, svfloat64_t_val); + svminv_s8(svbool_t_val, svint8_t_val); + svminv_s16(svbool_t_val, svint16_t_val); + svminv_s32(svbool_t_val, svint32_t_val); + svminv_s64(svbool_t_val, svint64_t_val); + svminv_u8(svbool_t_val, svuint8_t_val); + svminv_u16(svbool_t_val, svuint16_t_val); + svminv_u32(svbool_t_val, svuint32_t_val); + svminv_u64(svbool_t_val, svuint64_t_val); + svmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmov_b_z(svbool_t_val, svbool_t_val); + svmov_z(svbool_t_val, svbool_t_val); + svmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmul_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_lane(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane(svfloat64_t_val, svfloat64_t_val, 1); + svmul_lane_f16(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane_f32(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane_f64(svfloat64_t_val, svfloat64_t_val, 1); + svmul_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulx_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svnand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svneg_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_f16_x(svbool_t_val, svfloat16_t_val); + svneg_f16_z(svbool_t_val, svfloat16_t_val); + svneg_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_f32_x(svbool_t_val, svfloat32_t_val); + svneg_f32_z(svbool_t_val, svfloat32_t_val); + svneg_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_f64_x(svbool_t_val, svfloat64_t_val); + svneg_f64_z(svbool_t_val, svfloat64_t_val); + svneg_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_s8_x(svbool_t_val, svint8_t_val); + svneg_s8_z(svbool_t_val, svint8_t_val); + svneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_s16_x(svbool_t_val, svint16_t_val); + svneg_s16_z(svbool_t_val, svint16_t_val); + svneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_s32_x(svbool_t_val, svint32_t_val); + svneg_s32_z(svbool_t_val, svint32_t_val); + svneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s64_x(svbool_t_val, svint64_t_val); + svneg_s64_z(svbool_t_val, svint64_t_val); + svneg_x(svbool_t_val, svfloat16_t_val); + svneg_x(svbool_t_val, svfloat32_t_val); + svneg_x(svbool_t_val, svfloat64_t_val); + svneg_x(svbool_t_val, svint8_t_val); + svneg_x(svbool_t_val, svint16_t_val); + svneg_x(svbool_t_val, svint32_t_val); + svneg_x(svbool_t_val, svint64_t_val); + svneg_z(svbool_t_val, svfloat16_t_val); + svneg_z(svbool_t_val, svfloat32_t_val); + svneg_z(svbool_t_val, svfloat64_t_val); + svneg_z(svbool_t_val, svint8_t_val); + svneg_z(svbool_t_val, svint16_t_val); + svneg_z(svbool_t_val, svint32_t_val); + svneg_z(svbool_t_val, svint64_t_val); + svnmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnor_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnot_b_z(svbool_t_val, svbool_t_val); + svnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_s8_x(svbool_t_val, svint8_t_val); + svnot_s8_z(svbool_t_val, svint8_t_val); + svnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_s16_x(svbool_t_val, svint16_t_val); + svnot_s16_z(svbool_t_val, svint16_t_val); + svnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_s32_x(svbool_t_val, svint32_t_val); + svnot_s32_z(svbool_t_val, svint32_t_val); + svnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_s64_x(svbool_t_val, svint64_t_val); + svnot_s64_z(svbool_t_val, svint64_t_val); + svnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_u8_x(svbool_t_val, svuint8_t_val); + svnot_u8_z(svbool_t_val, svuint8_t_val); + svnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_u16_x(svbool_t_val, svuint16_t_val); + svnot_u16_z(svbool_t_val, svuint16_t_val); + svnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_u32_x(svbool_t_val, svuint32_t_val); + svnot_u32_z(svbool_t_val, svuint32_t_val); + svnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_u64_x(svbool_t_val, svuint64_t_val); + svnot_u64_z(svbool_t_val, svuint64_t_val); + svnot_x(svbool_t_val, svint8_t_val); + svnot_x(svbool_t_val, svint16_t_val); + svnot_x(svbool_t_val, svint32_t_val); + svnot_x(svbool_t_val, svint64_t_val); + svnot_x(svbool_t_val, svuint8_t_val); + svnot_x(svbool_t_val, svuint16_t_val); + svnot_x(svbool_t_val, svuint32_t_val); + svnot_x(svbool_t_val, svuint64_t_val); + svnot_z(svbool_t_val, svbool_t_val); + svnot_z(svbool_t_val, svint8_t_val); + svnot_z(svbool_t_val, svint16_t_val); + svnot_z(svbool_t_val, svint32_t_val); + svnot_z(svbool_t_val, svint64_t_val); + svnot_z(svbool_t_val, svuint8_t_val); + svnot_z(svbool_t_val, svuint16_t_val); + svnot_z(svbool_t_val, svuint32_t_val); + svnot_z(svbool_t_val, svuint64_t_val); + svorn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorv(svbool_t_val, svint8_t_val); + svorv(svbool_t_val, svint16_t_val); + svorv(svbool_t_val, svint32_t_val); + svorv(svbool_t_val, svint64_t_val); + svorv(svbool_t_val, svuint8_t_val); + svorv(svbool_t_val, svuint16_t_val); + svorv(svbool_t_val, svuint32_t_val); + svorv(svbool_t_val, svuint64_t_val); + svorv_s8(svbool_t_val, svint8_t_val); + svorv_s16(svbool_t_val, svint16_t_val); + svorv_s32(svbool_t_val, svint32_t_val); + svorv_s64(svbool_t_val, svint64_t_val); + svorv_u8(svbool_t_val, svuint8_t_val); + svorv_u16(svbool_t_val, svuint16_t_val); + svorv_u32(svbool_t_val, svuint32_t_val); + svorv_u64(svbool_t_val, svuint64_t_val); + svpfalse(); + svpfalse_b(); + svpfirst(svbool_t_val, svbool_t_val); + svpfirst_b(svbool_t_val, svbool_t_val); + svpnext_b8(svbool_t_val, svbool_t_val); + svpnext_b16(svbool_t_val, svbool_t_val); + svpnext_b32(svbool_t_val, svbool_t_val); + svpnext_b64(svbool_t_val, svbool_t_val); + svprfb(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfb_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfd(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfd_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfh(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfh_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfw(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfw_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svptest_any(svbool_t_val, svbool_t_val); + svptest_first(svbool_t_val, svbool_t_val); + svptest_last(svbool_t_val, svbool_t_val); + svptrue_b8(); + svptrue_b16(); + svptrue_b32(); + svptrue_b64(); + svptrue_pat_b8(SV_MUL3); + svptrue_pat_b16(SV_MUL3); + svptrue_pat_b32(SV_MUL3); + svptrue_pat_b64(SV_MUL3); + svqadd(svint8_t_val, int8_t_val); + svqadd(svint8_t_val, svint8_t_val); + svqadd(svint16_t_val, int16_t_val); + svqadd(svint16_t_val, svint16_t_val); + svqadd(svint32_t_val, int32_t_val); + svqadd(svint32_t_val, svint32_t_val); + svqadd(svint64_t_val, int64_t_val); + svqadd(svint64_t_val, svint64_t_val); + svqadd(svuint8_t_val, svuint8_t_val); + svqadd(svuint8_t_val, uint8_t_val); + svqadd(svuint16_t_val, svuint16_t_val); + svqadd(svuint16_t_val, uint16_t_val); + svqadd(svuint32_t_val, svuint32_t_val); + svqadd(svuint32_t_val, uint32_t_val); + svqadd(svuint64_t_val, svuint64_t_val); + svqadd(svuint64_t_val, uint64_t_val); + svqadd_n_s8(svint8_t_val, int8_t_val); + svqadd_n_s16(svint16_t_val, int16_t_val); + svqadd_n_s32(svint32_t_val, int32_t_val); + svqadd_n_s64(svint64_t_val, int64_t_val); + svqadd_n_u8(svuint8_t_val, uint8_t_val); + svqadd_n_u16(svuint16_t_val, uint16_t_val); + svqadd_n_u32(svuint32_t_val, uint32_t_val); + svqadd_n_u64(svuint64_t_val, uint64_t_val); + svqadd_s8(svint8_t_val, svint8_t_val); + svqadd_s16(svint16_t_val, svint16_t_val); + svqadd_s32(svint32_t_val, svint32_t_val); + svqadd_s64(svint64_t_val, svint64_t_val); + svqadd_u8(svuint8_t_val, svuint8_t_val); + svqadd_u16(svuint16_t_val, svuint16_t_val); + svqadd_u32(svuint32_t_val, svuint32_t_val); + svqadd_u64(svuint64_t_val, svuint64_t_val); + svqdecb(int32_t_val, 2); + svqdecb(int64_t_val, 2); + svqdecb(uint32_t_val, 2); + svqdecb(uint64_t_val, 2); + svqdecb_n_s32(int32_t_val, 2); + svqdecb_n_s64(int64_t_val, 2); + svqdecb_n_u32(uint32_t_val, 2); + svqdecb_n_u64(uint64_t_val, 2); + svqdecb_pat(int32_t_val, SV_MUL3, 2); + svqdecb_pat(int64_t_val, SV_MUL3, 2); + svqdecb_pat(uint32_t_val, SV_MUL3, 2); + svqdecb_pat(uint64_t_val, SV_MUL3, 2); + svqdecb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd(int32_t_val, 2); + svqdecd(int64_t_val, 2); + svqdecd(svint64_t_val, 2); + svqdecd(svuint64_t_val, 2); + svqdecd(uint32_t_val, 2); + svqdecd(uint64_t_val, 2); + svqdecd_n_s32(int32_t_val, 2); + svqdecd_n_s64(int64_t_val, 2); + svqdecd_n_u32(uint32_t_val, 2); + svqdecd_n_u64(uint64_t_val, 2); + svqdecd_pat(int32_t_val, SV_MUL3, 2); + svqdecd_pat(int64_t_val, SV_MUL3, 2); + svqdecd_pat(svint64_t_val, SV_MUL3, 2); + svqdecd_pat(svuint64_t_val, SV_MUL3, 2); + svqdecd_pat(uint32_t_val, SV_MUL3, 2); + svqdecd_pat(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqdecd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqdecd_s64(svint64_t_val, 2); + svqdecd_u64(svuint64_t_val, 2); + svqdech(int32_t_val, 2); + svqdech(int64_t_val, 2); + svqdech(svint16_t_val, 2); + svqdech(svuint16_t_val, 2); + svqdech(uint32_t_val, 2); + svqdech(uint64_t_val, 2); + svqdech_n_s32(int32_t_val, 2); + svqdech_n_s64(int64_t_val, 2); + svqdech_n_u32(uint32_t_val, 2); + svqdech_n_u64(uint64_t_val, 2); + svqdech_pat(int32_t_val, SV_MUL3, 2); + svqdech_pat(int64_t_val, SV_MUL3, 2); + svqdech_pat(svint16_t_val, SV_MUL3, 2); + svqdech_pat(svuint16_t_val, SV_MUL3, 2); + svqdech_pat(uint32_t_val, SV_MUL3, 2); + svqdech_pat(uint64_t_val, SV_MUL3, 2); + svqdech_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdech_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdech_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdech_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdech_pat_s16(svint16_t_val, SV_MUL3, 2); + svqdech_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqdech_s16(svint16_t_val, 2); + svqdech_u16(svuint16_t_val, 2); + svqdecp(svint16_t_val, svbool_t_val); + svqdecp(svint32_t_val, svbool_t_val); + svqdecp(svint64_t_val, svbool_t_val); + svqdecp(svuint16_t_val, svbool_t_val); + svqdecp(svuint32_t_val, svbool_t_val); + svqdecp(svuint64_t_val, svbool_t_val); + svqdecp_b8(int32_t_val, svbool_t_val); + svqdecp_b8(int64_t_val, svbool_t_val); + svqdecp_b8(uint32_t_val, svbool_t_val); + svqdecp_b8(uint64_t_val, svbool_t_val); + svqdecp_b16(int32_t_val, svbool_t_val); + svqdecp_b16(int64_t_val, svbool_t_val); + svqdecp_b16(uint32_t_val, svbool_t_val); + svqdecp_b16(uint64_t_val, svbool_t_val); + svqdecp_b32(int32_t_val, svbool_t_val); + svqdecp_b32(int64_t_val, svbool_t_val); + svqdecp_b32(uint32_t_val, svbool_t_val); + svqdecp_b32(uint64_t_val, svbool_t_val); + svqdecp_b64(int32_t_val, svbool_t_val); + svqdecp_b64(int64_t_val, svbool_t_val); + svqdecp_b64(uint32_t_val, svbool_t_val); + svqdecp_b64(uint64_t_val, svbool_t_val); + svqdecp_n_s32_b8(int32_t_val, svbool_t_val); + svqdecp_n_s32_b16(int32_t_val, svbool_t_val); + svqdecp_n_s32_b32(int32_t_val, svbool_t_val); + svqdecp_n_s32_b64(int32_t_val, svbool_t_val); + svqdecp_n_s64_b8(int64_t_val, svbool_t_val); + svqdecp_n_s64_b16(int64_t_val, svbool_t_val); + svqdecp_n_s64_b32(int64_t_val, svbool_t_val); + svqdecp_n_s64_b64(int64_t_val, svbool_t_val); + svqdecp_n_u32_b8(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b16(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b32(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b64(uint32_t_val, svbool_t_val); + svqdecp_n_u64_b8(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b16(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b32(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b64(uint64_t_val, svbool_t_val); + svqdecp_s16(svint16_t_val, svbool_t_val); + svqdecp_s32(svint32_t_val, svbool_t_val); + svqdecp_s64(svint64_t_val, svbool_t_val); + svqdecp_u16(svuint16_t_val, svbool_t_val); + svqdecp_u32(svuint32_t_val, svbool_t_val); + svqdecp_u64(svuint64_t_val, svbool_t_val); + svqdecw(int32_t_val, 2); + svqdecw(int64_t_val, 2); + svqdecw(svint32_t_val, 2); + svqdecw(svuint32_t_val, 2); + svqdecw(uint32_t_val, 2); + svqdecw(uint64_t_val, 2); + svqdecw_n_s32(int32_t_val, 2); + svqdecw_n_s64(int64_t_val, 2); + svqdecw_n_u32(uint32_t_val, 2); + svqdecw_n_u64(uint64_t_val, 2); + svqdecw_pat(int32_t_val, SV_MUL3, 2); + svqdecw_pat(int64_t_val, SV_MUL3, 2); + svqdecw_pat(svint32_t_val, SV_MUL3, 2); + svqdecw_pat(svuint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqdecw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqdecw_s32(svint32_t_val, 2); + svqdecw_u32(svuint32_t_val, 2); + svqincb(int32_t_val, 2); + svqincb(int64_t_val, 2); + svqincb(uint32_t_val, 2); + svqincb(uint64_t_val, 2); + svqincb_n_s32(int32_t_val, 2); + svqincb_n_s64(int64_t_val, 2); + svqincb_n_u32(uint32_t_val, 2); + svqincb_n_u64(uint64_t_val, 2); + svqincb_pat(int32_t_val, SV_MUL3, 2); + svqincb_pat(int64_t_val, SV_MUL3, 2); + svqincb_pat(uint32_t_val, SV_MUL3, 2); + svqincb_pat(uint64_t_val, SV_MUL3, 2); + svqincb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd(int32_t_val, 2); + svqincd(int64_t_val, 2); + svqincd(svint64_t_val, 2); + svqincd(svuint64_t_val, 2); + svqincd(uint32_t_val, 2); + svqincd(uint64_t_val, 2); + svqincd_n_s32(int32_t_val, 2); + svqincd_n_s64(int64_t_val, 2); + svqincd_n_u32(uint32_t_val, 2); + svqincd_n_u64(uint64_t_val, 2); + svqincd_pat(int32_t_val, SV_MUL3, 2); + svqincd_pat(int64_t_val, SV_MUL3, 2); + svqincd_pat(svint64_t_val, SV_MUL3, 2); + svqincd_pat(svuint64_t_val, SV_MUL3, 2); + svqincd_pat(uint32_t_val, SV_MUL3, 2); + svqincd_pat(uint64_t_val, SV_MUL3, 2); + svqincd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqincd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqincd_s64(svint64_t_val, 2); + svqincd_u64(svuint64_t_val, 2); + svqinch(int32_t_val, 2); + svqinch(int64_t_val, 2); + svqinch(svint16_t_val, 2); + svqinch(svuint16_t_val, 2); + svqinch(uint32_t_val, 2); + svqinch(uint64_t_val, 2); + svqinch_n_s32(int32_t_val, 2); + svqinch_n_s64(int64_t_val, 2); + svqinch_n_u32(uint32_t_val, 2); + svqinch_n_u64(uint64_t_val, 2); + svqinch_pat(int32_t_val, SV_MUL3, 2); + svqinch_pat(int64_t_val, SV_MUL3, 2); + svqinch_pat(svint16_t_val, SV_MUL3, 2); + svqinch_pat(svuint16_t_val, SV_MUL3, 2); + svqinch_pat(uint32_t_val, SV_MUL3, 2); + svqinch_pat(uint64_t_val, SV_MUL3, 2); + svqinch_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqinch_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqinch_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqinch_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqinch_pat_s16(svint16_t_val, SV_MUL3, 2); + svqinch_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqinch_s16(svint16_t_val, 2); + svqinch_u16(svuint16_t_val, 2); + svqincp(svint16_t_val, svbool_t_val); + svqincp(svint32_t_val, svbool_t_val); + svqincp(svint64_t_val, svbool_t_val); + svqincp(svuint16_t_val, svbool_t_val); + svqincp(svuint32_t_val, svbool_t_val); + svqincp(svuint64_t_val, svbool_t_val); + svqincp_b8(int32_t_val, svbool_t_val); + svqincp_b8(int64_t_val, svbool_t_val); + svqincp_b8(uint32_t_val, svbool_t_val); + svqincp_b8(uint64_t_val, svbool_t_val); + svqincp_b16(int32_t_val, svbool_t_val); + svqincp_b16(int64_t_val, svbool_t_val); + svqincp_b16(uint32_t_val, svbool_t_val); + svqincp_b16(uint64_t_val, svbool_t_val); + svqincp_b32(int32_t_val, svbool_t_val); + svqincp_b32(int64_t_val, svbool_t_val); + svqincp_b32(uint32_t_val, svbool_t_val); + svqincp_b32(uint64_t_val, svbool_t_val); + svqincp_b64(int32_t_val, svbool_t_val); + svqincp_b64(int64_t_val, svbool_t_val); + svqincp_b64(uint32_t_val, svbool_t_val); + svqincp_b64(uint64_t_val, svbool_t_val); + svqincp_n_s32_b8(int32_t_val, svbool_t_val); + svqincp_n_s32_b16(int32_t_val, svbool_t_val); + svqincp_n_s32_b32(int32_t_val, svbool_t_val); + svqincp_n_s32_b64(int32_t_val, svbool_t_val); + svqincp_n_s64_b8(int64_t_val, svbool_t_val); + svqincp_n_s64_b16(int64_t_val, svbool_t_val); + svqincp_n_s64_b32(int64_t_val, svbool_t_val); + svqincp_n_s64_b64(int64_t_val, svbool_t_val); + svqincp_n_u32_b8(uint32_t_val, svbool_t_val); + svqincp_n_u32_b16(uint32_t_val, svbool_t_val); + svqincp_n_u32_b32(uint32_t_val, svbool_t_val); + svqincp_n_u32_b64(uint32_t_val, svbool_t_val); + svqincp_n_u64_b8(uint64_t_val, svbool_t_val); + svqincp_n_u64_b16(uint64_t_val, svbool_t_val); + svqincp_n_u64_b32(uint64_t_val, svbool_t_val); + svqincp_n_u64_b64(uint64_t_val, svbool_t_val); + svqincp_s16(svint16_t_val, svbool_t_val); + svqincp_s32(svint32_t_val, svbool_t_val); + svqincp_s64(svint64_t_val, svbool_t_val); + svqincp_u16(svuint16_t_val, svbool_t_val); + svqincp_u32(svuint32_t_val, svbool_t_val); + svqincp_u64(svuint64_t_val, svbool_t_val); + svqincw(int32_t_val, 2); + svqincw(int64_t_val, 2); + svqincw(svint32_t_val, 2); + svqincw(svuint32_t_val, 2); + svqincw(uint32_t_val, 2); + svqincw(uint64_t_val, 2); + svqincw_n_s32(int32_t_val, 2); + svqincw_n_s64(int64_t_val, 2); + svqincw_n_u32(uint32_t_val, 2); + svqincw_n_u64(uint64_t_val, 2); + svqincw_pat(int32_t_val, SV_MUL3, 2); + svqincw_pat(int64_t_val, SV_MUL3, 2); + svqincw_pat(svint32_t_val, SV_MUL3, 2); + svqincw_pat(svuint32_t_val, SV_MUL3, 2); + svqincw_pat(uint32_t_val, SV_MUL3, 2); + svqincw_pat(uint64_t_val, SV_MUL3, 2); + svqincw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqincw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqincw_s32(svint32_t_val, 2); + svqincw_u32(svuint32_t_val, 2); + svqsub(svint8_t_val, int8_t_val); + svqsub(svint8_t_val, svint8_t_val); + svqsub(svint16_t_val, int16_t_val); + svqsub(svint16_t_val, svint16_t_val); + svqsub(svint32_t_val, int32_t_val); + svqsub(svint32_t_val, svint32_t_val); + svqsub(svint64_t_val, int64_t_val); + svqsub(svint64_t_val, svint64_t_val); + svqsub(svuint8_t_val, svuint8_t_val); + svqsub(svuint8_t_val, uint8_t_val); + svqsub(svuint16_t_val, svuint16_t_val); + svqsub(svuint16_t_val, uint16_t_val); + svqsub(svuint32_t_val, svuint32_t_val); + svqsub(svuint32_t_val, uint32_t_val); + svqsub(svuint64_t_val, svuint64_t_val); + svqsub(svuint64_t_val, uint64_t_val); + svqsub_n_s8(svint8_t_val, int8_t_val); + svqsub_n_s16(svint16_t_val, int16_t_val); + svqsub_n_s32(svint32_t_val, int32_t_val); + svqsub_n_s64(svint64_t_val, int64_t_val); + svqsub_n_u8(svuint8_t_val, uint8_t_val); + svqsub_n_u16(svuint16_t_val, uint16_t_val); + svqsub_n_u32(svuint32_t_val, uint32_t_val); + svqsub_n_u64(svuint64_t_val, uint64_t_val); + svqsub_s8(svint8_t_val, svint8_t_val); + svqsub_s16(svint16_t_val, svint16_t_val); + svqsub_s32(svint32_t_val, svint32_t_val); + svqsub_s64(svint64_t_val, svint64_t_val); + svqsub_u8(svuint8_t_val, svuint8_t_val); + svqsub_u16(svuint16_t_val, svuint16_t_val); + svqsub_u32(svuint32_t_val, svuint32_t_val); + svqsub_u64(svuint64_t_val, svuint64_t_val); + svrbit_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_s8_x(svbool_t_val, svint8_t_val); + svrbit_s8_z(svbool_t_val, svint8_t_val); + svrbit_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_s16_x(svbool_t_val, svint16_t_val); + svrbit_s16_z(svbool_t_val, svint16_t_val); + svrbit_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_s32_x(svbool_t_val, svint32_t_val); + svrbit_s32_z(svbool_t_val, svint32_t_val); + svrbit_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_s64_x(svbool_t_val, svint64_t_val); + svrbit_s64_z(svbool_t_val, svint64_t_val); + svrbit_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_u8_x(svbool_t_val, svuint8_t_val); + svrbit_u8_z(svbool_t_val, svuint8_t_val); + svrbit_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_u16_x(svbool_t_val, svuint16_t_val); + svrbit_u16_z(svbool_t_val, svuint16_t_val); + svrbit_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_u32_x(svbool_t_val, svuint32_t_val); + svrbit_u32_z(svbool_t_val, svuint32_t_val); + svrbit_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_u64_x(svbool_t_val, svuint64_t_val); + svrbit_u64_z(svbool_t_val, svuint64_t_val); + svrbit_x(svbool_t_val, svint8_t_val); + svrbit_x(svbool_t_val, svint16_t_val); + svrbit_x(svbool_t_val, svint32_t_val); + svrbit_x(svbool_t_val, svint64_t_val); + svrbit_x(svbool_t_val, svuint8_t_val); + svrbit_x(svbool_t_val, svuint16_t_val); + svrbit_x(svbool_t_val, svuint32_t_val); + svrbit_x(svbool_t_val, svuint64_t_val); + svrbit_z(svbool_t_val, svint8_t_val); + svrbit_z(svbool_t_val, svint16_t_val); + svrbit_z(svbool_t_val, svint32_t_val); + svrbit_z(svbool_t_val, svint64_t_val); + svrbit_z(svbool_t_val, svuint8_t_val); + svrbit_z(svbool_t_val, svuint16_t_val); + svrbit_z(svbool_t_val, svuint32_t_val); + svrbit_z(svbool_t_val, svuint64_t_val); + svrecpe(svfloat16_t_val); + svrecpe(svfloat32_t_val); + svrecpe(svfloat64_t_val); + svrecpe_f16(svfloat16_t_val); + svrecpe_f32(svfloat32_t_val); + svrecpe_f64(svfloat64_t_val); + svrecps(svfloat16_t_val, svfloat16_t_val); + svrecps(svfloat32_t_val, svfloat32_t_val); + svrecps(svfloat64_t_val, svfloat64_t_val); + svrecps_f16(svfloat16_t_val, svfloat16_t_val); + svrecps_f32(svfloat32_t_val, svfloat32_t_val); + svrecps_f64(svfloat64_t_val, svfloat64_t_val); + svrecpx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_f16_x(svbool_t_val, svfloat16_t_val); + svrecpx_f16_z(svbool_t_val, svfloat16_t_val); + svrecpx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_f32_x(svbool_t_val, svfloat32_t_val); + svrecpx_f32_z(svbool_t_val, svfloat32_t_val); + svrecpx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_f64_x(svbool_t_val, svfloat64_t_val); + svrecpx_f64_z(svbool_t_val, svfloat64_t_val); + svrecpx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_x(svbool_t_val, svfloat16_t_val); + svrecpx_x(svbool_t_val, svfloat32_t_val); + svrecpx_x(svbool_t_val, svfloat64_t_val); + svrecpx_z(svbool_t_val, svfloat16_t_val); + svrecpx_z(svbool_t_val, svfloat32_t_val); + svrecpx_z(svbool_t_val, svfloat64_t_val); + svrev(svbfloat16_t_val); + svrev(svfloat16_t_val); + svrev(svfloat32_t_val); + svrev(svfloat64_t_val); + svrev(svint8_t_val); + svrev(svint16_t_val); + svrev(svint32_t_val); + svrev(svint64_t_val); + svrev(svuint8_t_val); + svrev(svuint16_t_val); + svrev(svuint32_t_val); + svrev(svuint64_t_val); + svrev_b8(svbool_t_val); + svrev_b16(svbool_t_val); + svrev_b32(svbool_t_val); + svrev_b64(svbool_t_val); + svrev_bf16(svbfloat16_t_val); + svrev_f16(svfloat16_t_val); + svrev_f32(svfloat32_t_val); + svrev_f64(svfloat64_t_val); + svrev_s8(svint8_t_val); + svrev_s16(svint16_t_val); + svrev_s32(svint32_t_val); + svrev_s64(svint64_t_val); + svrev_u8(svuint8_t_val); + svrev_u16(svuint16_t_val); + svrev_u32(svuint32_t_val); + svrev_u64(svuint64_t_val); + svrevb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_s16_x(svbool_t_val, svint16_t_val); + svrevb_s16_z(svbool_t_val, svint16_t_val); + svrevb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_s32_x(svbool_t_val, svint32_t_val); + svrevb_s32_z(svbool_t_val, svint32_t_val); + svrevb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_s64_x(svbool_t_val, svint64_t_val); + svrevb_s64_z(svbool_t_val, svint64_t_val); + svrevb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_u16_x(svbool_t_val, svuint16_t_val); + svrevb_u16_z(svbool_t_val, svuint16_t_val); + svrevb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_u32_x(svbool_t_val, svuint32_t_val); + svrevb_u32_z(svbool_t_val, svuint32_t_val); + svrevb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_u64_x(svbool_t_val, svuint64_t_val); + svrevb_u64_z(svbool_t_val, svuint64_t_val); + svrevb_x(svbool_t_val, svint16_t_val); + svrevb_x(svbool_t_val, svint32_t_val); + svrevb_x(svbool_t_val, svint64_t_val); + svrevb_x(svbool_t_val, svuint16_t_val); + svrevb_x(svbool_t_val, svuint32_t_val); + svrevb_x(svbool_t_val, svuint64_t_val); + svrevb_z(svbool_t_val, svint16_t_val); + svrevb_z(svbool_t_val, svint32_t_val); + svrevb_z(svbool_t_val, svint64_t_val); + svrevb_z(svbool_t_val, svuint16_t_val); + svrevb_z(svbool_t_val, svuint32_t_val); + svrevb_z(svbool_t_val, svuint64_t_val); + svrevh_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_s32_x(svbool_t_val, svint32_t_val); + svrevh_s32_z(svbool_t_val, svint32_t_val); + svrevh_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_s64_x(svbool_t_val, svint64_t_val); + svrevh_s64_z(svbool_t_val, svint64_t_val); + svrevh_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_u32_x(svbool_t_val, svuint32_t_val); + svrevh_u32_z(svbool_t_val, svuint32_t_val); + svrevh_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_u64_x(svbool_t_val, svuint64_t_val); + svrevh_u64_z(svbool_t_val, svuint64_t_val); + svrevh_x(svbool_t_val, svint32_t_val); + svrevh_x(svbool_t_val, svint64_t_val); + svrevh_x(svbool_t_val, svuint32_t_val); + svrevh_x(svbool_t_val, svuint64_t_val); + svrevh_z(svbool_t_val, svint32_t_val); + svrevh_z(svbool_t_val, svint64_t_val); + svrevh_z(svbool_t_val, svuint32_t_val); + svrevh_z(svbool_t_val, svuint64_t_val); + svrevw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_s64_x(svbool_t_val, svint64_t_val); + svrevw_s64_z(svbool_t_val, svint64_t_val); + svrevw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_u64_x(svbool_t_val, svuint64_t_val); + svrevw_u64_z(svbool_t_val, svuint64_t_val); + svrevw_x(svbool_t_val, svint64_t_val); + svrevw_x(svbool_t_val, svuint64_t_val); + svrevw_z(svbool_t_val, svint64_t_val); + svrevw_z(svbool_t_val, svuint64_t_val); + svrinta_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_f16_x(svbool_t_val, svfloat16_t_val); + svrinta_f16_z(svbool_t_val, svfloat16_t_val); + svrinta_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_f32_x(svbool_t_val, svfloat32_t_val); + svrinta_f32_z(svbool_t_val, svfloat32_t_val); + svrinta_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_f64_x(svbool_t_val, svfloat64_t_val); + svrinta_f64_z(svbool_t_val, svfloat64_t_val); + svrinta_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_x(svbool_t_val, svfloat16_t_val); + svrinta_x(svbool_t_val, svfloat32_t_val); + svrinta_x(svbool_t_val, svfloat64_t_val); + svrinta_z(svbool_t_val, svfloat16_t_val); + svrinta_z(svbool_t_val, svfloat32_t_val); + svrinta_z(svbool_t_val, svfloat64_t_val); + svrinti_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_f16_x(svbool_t_val, svfloat16_t_val); + svrinti_f16_z(svbool_t_val, svfloat16_t_val); + svrinti_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_f32_x(svbool_t_val, svfloat32_t_val); + svrinti_f32_z(svbool_t_val, svfloat32_t_val); + svrinti_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_f64_x(svbool_t_val, svfloat64_t_val); + svrinti_f64_z(svbool_t_val, svfloat64_t_val); + svrinti_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_x(svbool_t_val, svfloat16_t_val); + svrinti_x(svbool_t_val, svfloat32_t_val); + svrinti_x(svbool_t_val, svfloat64_t_val); + svrinti_z(svbool_t_val, svfloat16_t_val); + svrinti_z(svbool_t_val, svfloat32_t_val); + svrinti_z(svbool_t_val, svfloat64_t_val); + svrintm_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_f16_x(svbool_t_val, svfloat16_t_val); + svrintm_f16_z(svbool_t_val, svfloat16_t_val); + svrintm_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_f32_x(svbool_t_val, svfloat32_t_val); + svrintm_f32_z(svbool_t_val, svfloat32_t_val); + svrintm_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_f64_x(svbool_t_val, svfloat64_t_val); + svrintm_f64_z(svbool_t_val, svfloat64_t_val); + svrintm_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_x(svbool_t_val, svfloat16_t_val); + svrintm_x(svbool_t_val, svfloat32_t_val); + svrintm_x(svbool_t_val, svfloat64_t_val); + svrintm_z(svbool_t_val, svfloat16_t_val); + svrintm_z(svbool_t_val, svfloat32_t_val); + svrintm_z(svbool_t_val, svfloat64_t_val); + svrintn_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_f16_x(svbool_t_val, svfloat16_t_val); + svrintn_f16_z(svbool_t_val, svfloat16_t_val); + svrintn_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_f32_x(svbool_t_val, svfloat32_t_val); + svrintn_f32_z(svbool_t_val, svfloat32_t_val); + svrintn_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_f64_x(svbool_t_val, svfloat64_t_val); + svrintn_f64_z(svbool_t_val, svfloat64_t_val); + svrintn_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_x(svbool_t_val, svfloat16_t_val); + svrintn_x(svbool_t_val, svfloat32_t_val); + svrintn_x(svbool_t_val, svfloat64_t_val); + svrintn_z(svbool_t_val, svfloat16_t_val); + svrintn_z(svbool_t_val, svfloat32_t_val); + svrintn_z(svbool_t_val, svfloat64_t_val); + svrintp_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_f16_x(svbool_t_val, svfloat16_t_val); + svrintp_f16_z(svbool_t_val, svfloat16_t_val); + svrintp_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_f32_x(svbool_t_val, svfloat32_t_val); + svrintp_f32_z(svbool_t_val, svfloat32_t_val); + svrintp_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_f64_x(svbool_t_val, svfloat64_t_val); + svrintp_f64_z(svbool_t_val, svfloat64_t_val); + svrintp_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_x(svbool_t_val, svfloat16_t_val); + svrintp_x(svbool_t_val, svfloat32_t_val); + svrintp_x(svbool_t_val, svfloat64_t_val); + svrintp_z(svbool_t_val, svfloat16_t_val); + svrintp_z(svbool_t_val, svfloat32_t_val); + svrintp_z(svbool_t_val, svfloat64_t_val); + svrintx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_f16_x(svbool_t_val, svfloat16_t_val); + svrintx_f16_z(svbool_t_val, svfloat16_t_val); + svrintx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_f32_x(svbool_t_val, svfloat32_t_val); + svrintx_f32_z(svbool_t_val, svfloat32_t_val); + svrintx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_f64_x(svbool_t_val, svfloat64_t_val); + svrintx_f64_z(svbool_t_val, svfloat64_t_val); + svrintx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_x(svbool_t_val, svfloat16_t_val); + svrintx_x(svbool_t_val, svfloat32_t_val); + svrintx_x(svbool_t_val, svfloat64_t_val); + svrintx_z(svbool_t_val, svfloat16_t_val); + svrintx_z(svbool_t_val, svfloat32_t_val); + svrintx_z(svbool_t_val, svfloat64_t_val); + svrintz_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_f16_x(svbool_t_val, svfloat16_t_val); + svrintz_f16_z(svbool_t_val, svfloat16_t_val); + svrintz_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_f32_x(svbool_t_val, svfloat32_t_val); + svrintz_f32_z(svbool_t_val, svfloat32_t_val); + svrintz_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_f64_x(svbool_t_val, svfloat64_t_val); + svrintz_f64_z(svbool_t_val, svfloat64_t_val); + svrintz_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_x(svbool_t_val, svfloat16_t_val); + svrintz_x(svbool_t_val, svfloat32_t_val); + svrintz_x(svbool_t_val, svfloat64_t_val); + svrintz_z(svbool_t_val, svfloat16_t_val); + svrintz_z(svbool_t_val, svfloat32_t_val); + svrintz_z(svbool_t_val, svfloat64_t_val); + svrsqrte(svfloat16_t_val); + svrsqrte(svfloat32_t_val); + svrsqrte(svfloat64_t_val); + svrsqrte_f16(svfloat16_t_val); + svrsqrte_f32(svfloat32_t_val); + svrsqrte_f64(svfloat64_t_val); + svrsqrts(svfloat16_t_val, svfloat16_t_val); + svrsqrts(svfloat32_t_val, svfloat32_t_val); + svrsqrts(svfloat64_t_val, svfloat64_t_val); + svrsqrts_f16(svfloat16_t_val, svfloat16_t_val); + svrsqrts_f32(svfloat32_t_val, svfloat32_t_val); + svrsqrts_f64(svfloat64_t_val, svfloat64_t_val); + svscale_f16_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f32_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f64_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_n_f16_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f32_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f64_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svsel(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel(svbool_t_val, svbool_t_val, svbool_t_val); + svsel(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel(svbool_t_val, svint8_t_val, svint8_t_val); + svsel(svbool_t_val, svint16_t_val, svint16_t_val); + svsel(svbool_t_val, svint32_t_val, svint32_t_val); + svsel(svbool_t_val, svint64_t_val, svint64_t_val); + svsel(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsel_b(svbool_t_val, svbool_t_val, svbool_t_val); + svsel_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsel_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsel_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsel_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsel_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svset2(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2(svint8x2_t_val, 1, svint8_t_val); + svset2(svint16x2_t_val, 1, svint16_t_val); + svset2(svint32x2_t_val, 1, svint32_t_val); + svset2(svint64x2_t_val, 1, svint64_t_val); + svset2(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2(svuint8x2_t_val, 1, svuint8_t_val); + svset2(svuint16x2_t_val, 1, svuint16_t_val); + svset2(svuint32x2_t_val, 1, svuint32_t_val); + svset2(svuint64x2_t_val, 1, svuint64_t_val); + svset2_bf16(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2_f16(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2_f32(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2_f64(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2_mf8(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2_s8(svint8x2_t_val, 1, svint8_t_val); + svset2_s16(svint16x2_t_val, 1, svint16_t_val); + svset2_s32(svint32x2_t_val, 1, svint32_t_val); + svset2_s64(svint64x2_t_val, 1, svint64_t_val); + svset2_u8(svuint8x2_t_val, 1, svuint8_t_val); + svset2_u16(svuint16x2_t_val, 1, svuint16_t_val); + svset2_u32(svuint32x2_t_val, 1, svuint32_t_val); + svset2_u64(svuint64x2_t_val, 1, svuint64_t_val); + svset3(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3(svint8x3_t_val, 2, svint8_t_val); + svset3(svint16x3_t_val, 2, svint16_t_val); + svset3(svint32x3_t_val, 2, svint32_t_val); + svset3(svint64x3_t_val, 2, svint64_t_val); + svset3(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3(svuint8x3_t_val, 2, svuint8_t_val); + svset3(svuint16x3_t_val, 2, svuint16_t_val); + svset3(svuint32x3_t_val, 2, svuint32_t_val); + svset3(svuint64x3_t_val, 2, svuint64_t_val); + svset3_bf16(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3_f16(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3_f32(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3_f64(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3_mf8(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3_s8(svint8x3_t_val, 2, svint8_t_val); + svset3_s16(svint16x3_t_val, 2, svint16_t_val); + svset3_s32(svint32x3_t_val, 2, svint32_t_val); + svset3_s64(svint64x3_t_val, 2, svint64_t_val); + svset3_u8(svuint8x3_t_val, 2, svuint8_t_val); + svset3_u16(svuint16x3_t_val, 2, svuint16_t_val); + svset3_u32(svuint32x3_t_val, 2, svuint32_t_val); + svset3_u64(svuint64x3_t_val, 2, svuint64_t_val); + svset4(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4(svint8x4_t_val, 2, svint8_t_val); + svset4(svint16x4_t_val, 2, svint16_t_val); + svset4(svint32x4_t_val, 2, svint32_t_val); + svset4(svint64x4_t_val, 2, svint64_t_val); + svset4(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4(svuint8x4_t_val, 2, svuint8_t_val); + svset4(svuint16x4_t_val, 2, svuint16_t_val); + svset4(svuint32x4_t_val, 2, svuint32_t_val); + svset4(svuint64x4_t_val, 2, svuint64_t_val); + svset4_bf16(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4_f16(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4_f32(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4_f64(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4_mf8(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4_s8(svint8x4_t_val, 2, svint8_t_val); + svset4_s16(svint16x4_t_val, 2, svint16_t_val); + svset4_s32(svint32x4_t_val, 2, svint32_t_val); + svset4_s64(svint64x4_t_val, 2, svint64_t_val); + svset4_u8(svuint8x4_t_val, 2, svuint8_t_val); + svset4_u16(svuint16x4_t_val, 2, svuint16_t_val); + svset4_u32(svuint32x4_t_val, 2, svuint32_t_val); + svset4_u64(svuint64x4_t_val, 2, svuint64_t_val); + svsplice(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsplice_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsqrt_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_f16_x(svbool_t_val, svfloat16_t_val); + svsqrt_f16_z(svbool_t_val, svfloat16_t_val); + svsqrt_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_f32_x(svbool_t_val, svfloat32_t_val); + svsqrt_f32_z(svbool_t_val, svfloat32_t_val); + svsqrt_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_f64_x(svbool_t_val, svfloat64_t_val); + svsqrt_f64_z(svbool_t_val, svfloat64_t_val); + svsqrt_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_x(svbool_t_val, svfloat16_t_val); + svsqrt_x(svbool_t_val, svfloat32_t_val); + svsqrt_x(svbool_t_val, svfloat64_t_val); + svsqrt_z(svbool_t_val, svfloat16_t_val); + svsqrt_z(svbool_t_val, svfloat32_t_val); + svsqrt_z(svbool_t_val, svfloat64_t_val); + svst1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_s16(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b_u16(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst2(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svstnt1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svstnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svsub_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svtbl(svbfloat16_t_val, svuint16_t_val); + svtbl(svfloat16_t_val, svuint16_t_val); + svtbl(svfloat32_t_val, svuint32_t_val); + svtbl(svfloat64_t_val, svuint64_t_val); + svtbl(svint8_t_val, svuint8_t_val); + svtbl(svint16_t_val, svuint16_t_val); + svtbl(svint32_t_val, svuint32_t_val); + svtbl(svint64_t_val, svuint64_t_val); + svtbl(svuint8_t_val, svuint8_t_val); + svtbl(svuint16_t_val, svuint16_t_val); + svtbl(svuint32_t_val, svuint32_t_val); + svtbl(svuint64_t_val, svuint64_t_val); + svtbl_bf16(svbfloat16_t_val, svuint16_t_val); + svtbl_f16(svfloat16_t_val, svuint16_t_val); + svtbl_f32(svfloat32_t_val, svuint32_t_val); + svtbl_f64(svfloat64_t_val, svuint64_t_val); + svtbl_s8(svint8_t_val, svuint8_t_val); + svtbl_s16(svint16_t_val, svuint16_t_val); + svtbl_s32(svint32_t_val, svuint32_t_val); + svtbl_s64(svint64_t_val, svuint64_t_val); + svtbl_u8(svuint8_t_val, svuint8_t_val); + svtbl_u16(svuint16_t_val, svuint16_t_val); + svtbl_u32(svuint32_t_val, svuint32_t_val); + svtbl_u64(svuint64_t_val, svuint64_t_val); + svtrn1(svbfloat16_t_val, svbfloat16_t_val); + svtrn1(svfloat16_t_val, svfloat16_t_val); + svtrn1(svfloat32_t_val, svfloat32_t_val); + svtrn1(svfloat64_t_val, svfloat64_t_val); + svtrn1(svint8_t_val, svint8_t_val); + svtrn1(svint16_t_val, svint16_t_val); + svtrn1(svint32_t_val, svint32_t_val); + svtrn1(svint64_t_val, svint64_t_val); + svtrn1(svuint8_t_val, svuint8_t_val); + svtrn1(svuint16_t_val, svuint16_t_val); + svtrn1(svuint32_t_val, svuint32_t_val); + svtrn1(svuint64_t_val, svuint64_t_val); + svtrn1_b8(svbool_t_val, svbool_t_val); + svtrn1_b16(svbool_t_val, svbool_t_val); + svtrn1_b32(svbool_t_val, svbool_t_val); + svtrn1_b64(svbool_t_val, svbool_t_val); + svtrn1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn1_f16(svfloat16_t_val, svfloat16_t_val); + svtrn1_f32(svfloat32_t_val, svfloat32_t_val); + svtrn1_f64(svfloat64_t_val, svfloat64_t_val); + svtrn1_s8(svint8_t_val, svint8_t_val); + svtrn1_s16(svint16_t_val, svint16_t_val); + svtrn1_s32(svint32_t_val, svint32_t_val); + svtrn1_s64(svint64_t_val, svint64_t_val); + svtrn1_u8(svuint8_t_val, svuint8_t_val); + svtrn1_u16(svuint16_t_val, svuint16_t_val); + svtrn1_u32(svuint32_t_val, svuint32_t_val); + svtrn1_u64(svuint64_t_val, svuint64_t_val); + svtrn2(svbfloat16_t_val, svbfloat16_t_val); + svtrn2(svfloat16_t_val, svfloat16_t_val); + svtrn2(svfloat32_t_val, svfloat32_t_val); + svtrn2(svfloat64_t_val, svfloat64_t_val); + svtrn2(svint8_t_val, svint8_t_val); + svtrn2(svint16_t_val, svint16_t_val); + svtrn2(svint32_t_val, svint32_t_val); + svtrn2(svint64_t_val, svint64_t_val); + svtrn2(svuint8_t_val, svuint8_t_val); + svtrn2(svuint16_t_val, svuint16_t_val); + svtrn2(svuint32_t_val, svuint32_t_val); + svtrn2(svuint64_t_val, svuint64_t_val); + svtrn2_b8(svbool_t_val, svbool_t_val); + svtrn2_b16(svbool_t_val, svbool_t_val); + svtrn2_b32(svbool_t_val, svbool_t_val); + svtrn2_b64(svbool_t_val, svbool_t_val); + svtrn2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn2_f16(svfloat16_t_val, svfloat16_t_val); + svtrn2_f32(svfloat32_t_val, svfloat32_t_val); + svtrn2_f64(svfloat64_t_val, svfloat64_t_val); + svtrn2_s8(svint8_t_val, svint8_t_val); + svtrn2_s16(svint16_t_val, svint16_t_val); + svtrn2_s32(svint32_t_val, svint32_t_val); + svtrn2_s64(svint64_t_val, svint64_t_val); + svtrn2_u8(svuint8_t_val, svuint8_t_val); + svtrn2_u16(svuint16_t_val, svuint16_t_val); + svtrn2_u32(svuint32_t_val, svuint32_t_val); + svtrn2_u64(svuint64_t_val, svuint64_t_val); + svundef2_bf16(); + svundef2_f16(); + svundef2_f32(); + svundef2_f64(); + svundef2_mf8(); + svundef2_s8(); + svundef2_s16(); + svundef2_s32(); + svundef2_s64(); + svundef2_u8(); + svundef2_u16(); + svundef2_u32(); + svundef2_u64(); + svundef3_bf16(); + svundef3_f16(); + svundef3_f32(); + svundef3_f64(); + svundef3_mf8(); + svundef3_s8(); + svundef3_s16(); + svundef3_s32(); + svundef3_s64(); + svundef3_u8(); + svundef3_u16(); + svundef3_u32(); + svundef3_u64(); + svundef4_bf16(); + svundef4_f16(); + svundef4_f32(); + svundef4_f64(); + svundef4_mf8(); + svundef4_s8(); + svundef4_s16(); + svundef4_s32(); + svundef4_s64(); + svundef4_u8(); + svundef4_u16(); + svundef4_u32(); + svundef4_u64(); + svundef_bf16(); + svundef_f16(); + svundef_f32(); + svundef_f64(); + svundef_mf8(); + svundef_s8(); + svundef_s16(); + svundef_s32(); + svundef_s64(); + svundef_u8(); + svundef_u16(); + svundef_u32(); + svundef_u64(); + svunpkhi(svbool_t_val); + svunpkhi(svint8_t_val); + svunpkhi(svint16_t_val); + svunpkhi(svint32_t_val); + svunpkhi(svuint8_t_val); + svunpkhi(svuint16_t_val); + svunpkhi(svuint32_t_val); + svunpkhi_b(svbool_t_val); + svunpkhi_s16(svint8_t_val); + svunpkhi_s32(svint16_t_val); + svunpkhi_s64(svint32_t_val); + svunpkhi_u16(svuint8_t_val); + svunpkhi_u32(svuint16_t_val); + svunpkhi_u64(svuint32_t_val); + svunpklo(svbool_t_val); + svunpklo(svint8_t_val); + svunpklo(svint16_t_val); + svunpklo(svint32_t_val); + svunpklo(svuint8_t_val); + svunpklo(svuint16_t_val); + svunpklo(svuint32_t_val); + svunpklo_b(svbool_t_val); + svunpklo_s16(svint8_t_val); + svunpklo_s32(svint16_t_val); + svunpklo_s64(svint32_t_val); + svunpklo_u16(svuint8_t_val); + svunpklo_u32(svuint16_t_val); + svunpklo_u64(svuint32_t_val); + svuzp1(svbfloat16_t_val, svbfloat16_t_val); + svuzp1(svfloat16_t_val, svfloat16_t_val); + svuzp1(svfloat32_t_val, svfloat32_t_val); + svuzp1(svfloat64_t_val, svfloat64_t_val); + svuzp1(svint8_t_val, svint8_t_val); + svuzp1(svint16_t_val, svint16_t_val); + svuzp1(svint32_t_val, svint32_t_val); + svuzp1(svint64_t_val, svint64_t_val); + svuzp1(svuint8_t_val, svuint8_t_val); + svuzp1(svuint16_t_val, svuint16_t_val); + svuzp1(svuint32_t_val, svuint32_t_val); + svuzp1(svuint64_t_val, svuint64_t_val); + svuzp1_b8(svbool_t_val, svbool_t_val); + svuzp1_b16(svbool_t_val, svbool_t_val); + svuzp1_b32(svbool_t_val, svbool_t_val); + svuzp1_b64(svbool_t_val, svbool_t_val); + svuzp1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp1_f16(svfloat16_t_val, svfloat16_t_val); + svuzp1_f32(svfloat32_t_val, svfloat32_t_val); + svuzp1_f64(svfloat64_t_val, svfloat64_t_val); + svuzp1_s8(svint8_t_val, svint8_t_val); + svuzp1_s16(svint16_t_val, svint16_t_val); + svuzp1_s32(svint32_t_val, svint32_t_val); + svuzp1_s64(svint64_t_val, svint64_t_val); + svuzp1_u8(svuint8_t_val, svuint8_t_val); + svuzp1_u16(svuint16_t_val, svuint16_t_val); + svuzp1_u32(svuint32_t_val, svuint32_t_val); + svuzp1_u64(svuint64_t_val, svuint64_t_val); + svuzp2(svbfloat16_t_val, svbfloat16_t_val); + svuzp2(svfloat16_t_val, svfloat16_t_val); + svuzp2(svfloat32_t_val, svfloat32_t_val); + svuzp2(svfloat64_t_val, svfloat64_t_val); + svuzp2(svint8_t_val, svint8_t_val); + svuzp2(svint16_t_val, svint16_t_val); + svuzp2(svint32_t_val, svint32_t_val); + svuzp2(svint64_t_val, svint64_t_val); + svuzp2(svuint8_t_val, svuint8_t_val); + svuzp2(svuint16_t_val, svuint16_t_val); + svuzp2(svuint32_t_val, svuint32_t_val); + svuzp2(svuint64_t_val, svuint64_t_val); + svuzp2_b8(svbool_t_val, svbool_t_val); + svuzp2_b16(svbool_t_val, svbool_t_val); + svuzp2_b32(svbool_t_val, svbool_t_val); + svuzp2_b64(svbool_t_val, svbool_t_val); + svuzp2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp2_f16(svfloat16_t_val, svfloat16_t_val); + svuzp2_f32(svfloat32_t_val, svfloat32_t_val); + svuzp2_f64(svfloat64_t_val, svfloat64_t_val); + svuzp2_s8(svint8_t_val, svint8_t_val); + svuzp2_s16(svint16_t_val, svint16_t_val); + svuzp2_s32(svint32_t_val, svint32_t_val); + svuzp2_s64(svint64_t_val, svint64_t_val); + svuzp2_u8(svuint8_t_val, svuint8_t_val); + svuzp2_u16(svuint16_t_val, svuint16_t_val); + svuzp2_u32(svuint32_t_val, svuint32_t_val); + svuzp2_u64(svuint64_t_val, svuint64_t_val); + svwhilele_b8(int32_t_val, int32_t_val); + svwhilele_b8(int64_t_val, int64_t_val); + svwhilele_b8(uint32_t_val, uint32_t_val); + svwhilele_b8(uint64_t_val, uint64_t_val); + svwhilele_b8_s32(int32_t_val, int32_t_val); + svwhilele_b8_s64(int64_t_val, int64_t_val); + svwhilele_b8_u32(uint32_t_val, uint32_t_val); + svwhilele_b8_u64(uint64_t_val, uint64_t_val); + svwhilele_b16(int32_t_val, int32_t_val); + svwhilele_b16(int64_t_val, int64_t_val); + svwhilele_b16(uint32_t_val, uint32_t_val); + svwhilele_b16(uint64_t_val, uint64_t_val); + svwhilele_b16_s32(int32_t_val, int32_t_val); + svwhilele_b16_s64(int64_t_val, int64_t_val); + svwhilele_b16_u32(uint32_t_val, uint32_t_val); + svwhilele_b16_u64(uint64_t_val, uint64_t_val); + svwhilele_b32(int32_t_val, int32_t_val); + svwhilele_b32(int64_t_val, int64_t_val); + svwhilele_b32(uint32_t_val, uint32_t_val); + svwhilele_b32(uint64_t_val, uint64_t_val); + svwhilele_b32_s32(int32_t_val, int32_t_val); + svwhilele_b32_s64(int64_t_val, int64_t_val); + svwhilele_b32_u32(uint32_t_val, uint32_t_val); + svwhilele_b32_u64(uint64_t_val, uint64_t_val); + svwhilele_b64(int32_t_val, int32_t_val); + svwhilele_b64(int64_t_val, int64_t_val); + svwhilele_b64(uint32_t_val, uint32_t_val); + svwhilele_b64(uint64_t_val, uint64_t_val); + svwhilele_b64_s32(int32_t_val, int32_t_val); + svwhilele_b64_s64(int64_t_val, int64_t_val); + svwhilele_b64_u32(uint32_t_val, uint32_t_val); + svwhilele_b64_u64(uint64_t_val, uint64_t_val); + svwhilelt_b8(int32_t_val, int32_t_val); + svwhilelt_b8(int64_t_val, int64_t_val); + svwhilelt_b8(uint32_t_val, uint32_t_val); + svwhilelt_b8(uint64_t_val, uint64_t_val); + svwhilelt_b8_s32(int32_t_val, int32_t_val); + svwhilelt_b8_s64(int64_t_val, int64_t_val); + svwhilelt_b8_u32(uint32_t_val, uint32_t_val); + svwhilelt_b8_u64(uint64_t_val, uint64_t_val); + svwhilelt_b16(int32_t_val, int32_t_val); + svwhilelt_b16(int64_t_val, int64_t_val); + svwhilelt_b16(uint32_t_val, uint32_t_val); + svwhilelt_b16(uint64_t_val, uint64_t_val); + svwhilelt_b16_s32(int32_t_val, int32_t_val); + svwhilelt_b16_s64(int64_t_val, int64_t_val); + svwhilelt_b16_u32(uint32_t_val, uint32_t_val); + svwhilelt_b16_u64(uint64_t_val, uint64_t_val); + svwhilelt_b32(int32_t_val, int32_t_val); + svwhilelt_b32(int64_t_val, int64_t_val); + svwhilelt_b32(uint32_t_val, uint32_t_val); + svwhilelt_b32(uint64_t_val, uint64_t_val); + svwhilelt_b32_s32(int32_t_val, int32_t_val); + svwhilelt_b32_s64(int64_t_val, int64_t_val); + svwhilelt_b32_u32(uint32_t_val, uint32_t_val); + svwhilelt_b32_u64(uint64_t_val, uint64_t_val); + svwhilelt_b64(int32_t_val, int32_t_val); + svwhilelt_b64(int64_t_val, int64_t_val); + svwhilelt_b64(uint32_t_val, uint32_t_val); + svwhilelt_b64(uint64_t_val, uint64_t_val); + svwhilelt_b64_s32(int32_t_val, int32_t_val); + svwhilelt_b64_s64(int64_t_val, int64_t_val); + svwhilelt_b64_u32(uint32_t_val, uint32_t_val); + svwhilelt_b64_u64(uint64_t_val, uint64_t_val); + svzip1(svbfloat16_t_val, svbfloat16_t_val); + svzip1(svfloat16_t_val, svfloat16_t_val); + svzip1(svfloat32_t_val, svfloat32_t_val); + svzip1(svfloat64_t_val, svfloat64_t_val); + svzip1(svint8_t_val, svint8_t_val); + svzip1(svint16_t_val, svint16_t_val); + svzip1(svint32_t_val, svint32_t_val); + svzip1(svint64_t_val, svint64_t_val); + svzip1(svuint8_t_val, svuint8_t_val); + svzip1(svuint16_t_val, svuint16_t_val); + svzip1(svuint32_t_val, svuint32_t_val); + svzip1(svuint64_t_val, svuint64_t_val); + svzip1_b8(svbool_t_val, svbool_t_val); + svzip1_b16(svbool_t_val, svbool_t_val); + svzip1_b32(svbool_t_val, svbool_t_val); + svzip1_b64(svbool_t_val, svbool_t_val); + svzip1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip1_f16(svfloat16_t_val, svfloat16_t_val); + svzip1_f32(svfloat32_t_val, svfloat32_t_val); + svzip1_f64(svfloat64_t_val, svfloat64_t_val); + svzip1_s8(svint8_t_val, svint8_t_val); + svzip1_s16(svint16_t_val, svint16_t_val); + svzip1_s32(svint32_t_val, svint32_t_val); + svzip1_s64(svint64_t_val, svint64_t_val); + svzip1_u8(svuint8_t_val, svuint8_t_val); + svzip1_u16(svuint16_t_val, svuint16_t_val); + svzip1_u32(svuint32_t_val, svuint32_t_val); + svzip1_u64(svuint64_t_val, svuint64_t_val); + svzip2(svbfloat16_t_val, svbfloat16_t_val); + svzip2(svfloat16_t_val, svfloat16_t_val); + svzip2(svfloat32_t_val, svfloat32_t_val); + svzip2(svfloat64_t_val, svfloat64_t_val); + svzip2(svint8_t_val, svint8_t_val); + svzip2(svint16_t_val, svint16_t_val); + svzip2(svint32_t_val, svint32_t_val); + svzip2(svint64_t_val, svint64_t_val); + svzip2(svuint8_t_val, svuint8_t_val); + svzip2(svuint16_t_val, svuint16_t_val); + svzip2(svuint32_t_val, svuint32_t_val); + svzip2(svuint64_t_val, svuint64_t_val); + svzip2_b8(svbool_t_val, svbool_t_val); + svzip2_b16(svbool_t_val, svbool_t_val); + svzip2_b32(svbool_t_val, svbool_t_val); + svzip2_b64(svbool_t_val, svbool_t_val); + svzip2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip2_f16(svfloat16_t_val, svfloat16_t_val); + svzip2_f32(svfloat32_t_val, svfloat32_t_val); + svzip2_f64(svfloat64_t_val, svfloat64_t_val); + svzip2_s8(svint8_t_val, svint8_t_val); + svzip2_s16(svint16_t_val, svint16_t_val); + svzip2_s32(svint32_t_val, svint32_t_val); + svzip2_s64(svint64_t_val, svint64_t_val); + svzip2_u8(svuint8_t_val, svuint8_t_val); + svzip2_u16(svuint16_t_val, svuint16_t_val); + svzip2_u32(svuint32_t_val, svuint32_t_val); + svzip2_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + bfloat16_t bfloat16_t_val; + bool bool_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + void * void_ptr_val; + + svabd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabs_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_f16_x(svbool_t_val, svfloat16_t_val); + svabs_f16_z(svbool_t_val, svfloat16_t_val); + svabs_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_f32_x(svbool_t_val, svfloat32_t_val); + svabs_f32_z(svbool_t_val, svfloat32_t_val); + svabs_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_f64_x(svbool_t_val, svfloat64_t_val); + svabs_f64_z(svbool_t_val, svfloat64_t_val); + svabs_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_s8_x(svbool_t_val, svint8_t_val); + svabs_s8_z(svbool_t_val, svint8_t_val); + svabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_s16_x(svbool_t_val, svint16_t_val); + svabs_s16_z(svbool_t_val, svint16_t_val); + svabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_s32_x(svbool_t_val, svint32_t_val); + svabs_s32_z(svbool_t_val, svint32_t_val); + svabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s64_x(svbool_t_val, svint64_t_val); + svabs_s64_z(svbool_t_val, svint64_t_val); + svabs_x(svbool_t_val, svfloat16_t_val); + svabs_x(svbool_t_val, svfloat32_t_val); + svabs_x(svbool_t_val, svfloat64_t_val); + svabs_x(svbool_t_val, svint8_t_val); + svabs_x(svbool_t_val, svint16_t_val); + svabs_x(svbool_t_val, svint32_t_val); + svabs_x(svbool_t_val, svint64_t_val); + svabs_z(svbool_t_val, svfloat16_t_val); + svabs_z(svbool_t_val, svfloat32_t_val); + svabs_z(svbool_t_val, svfloat64_t_val); + svabs_z(svbool_t_val, svint8_t_val); + svabs_z(svbool_t_val, svint16_t_val); + svabs_z(svbool_t_val, svint32_t_val); + svabs_z(svbool_t_val, svint64_t_val); + svacge(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge(svbool_t_val, svfloat64_t_val, float64_t_val); + svacge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svaddv(svbool_t_val, svfloat16_t_val); + svaddv(svbool_t_val, svfloat32_t_val); + svaddv(svbool_t_val, svfloat64_t_val); + svaddv(svbool_t_val, svint8_t_val); + svaddv(svbool_t_val, svint16_t_val); + svaddv(svbool_t_val, svint32_t_val); + svaddv(svbool_t_val, svint64_t_val); + svaddv(svbool_t_val, svuint8_t_val); + svaddv(svbool_t_val, svuint16_t_val); + svaddv(svbool_t_val, svuint32_t_val); + svaddv(svbool_t_val, svuint64_t_val); + svaddv_f16(svbool_t_val, svfloat16_t_val); + svaddv_f32(svbool_t_val, svfloat32_t_val); + svaddv_f64(svbool_t_val, svfloat64_t_val); + svaddv_s8(svbool_t_val, svint8_t_val); + svaddv_s16(svbool_t_val, svint16_t_val); + svaddv_s32(svbool_t_val, svint32_t_val); + svaddv_s64(svbool_t_val, svint64_t_val); + svaddv_u8(svbool_t_val, svuint8_t_val); + svaddv_u16(svbool_t_val, svuint16_t_val); + svaddv_u32(svbool_t_val, svuint32_t_val); + svaddv_u64(svbool_t_val, svuint64_t_val); + svand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svandv(svbool_t_val, svint8_t_val); + svandv(svbool_t_val, svint16_t_val); + svandv(svbool_t_val, svint32_t_val); + svandv(svbool_t_val, svint64_t_val); + svandv(svbool_t_val, svuint8_t_val); + svandv(svbool_t_val, svuint16_t_val); + svandv(svbool_t_val, svuint32_t_val); + svandv(svbool_t_val, svuint64_t_val); + svandv_s8(svbool_t_val, svint8_t_val); + svandv_s16(svbool_t_val, svint16_t_val); + svandv_s32(svbool_t_val, svint32_t_val); + svandv_s64(svbool_t_val, svint64_t_val); + svandv_u8(svbool_t_val, svuint8_t_val); + svandv_u16(svbool_t_val, svuint16_t_val); + svandv_u32(svbool_t_val, svuint32_t_val); + svandv_u64(svbool_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasrd_m(svbool_t_val, svint8_t_val, 2); + svasrd_m(svbool_t_val, svint16_t_val, 2); + svasrd_m(svbool_t_val, svint32_t_val, 2); + svasrd_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s8_m(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_x(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_z(svbool_t_val, svint8_t_val, 2); + svasrd_n_s16_m(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_x(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_z(svbool_t_val, svint16_t_val, 2); + svasrd_n_s32_m(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_x(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_z(svbool_t_val, svint32_t_val, 2); + svasrd_n_s64_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_x(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_z(svbool_t_val, svint64_t_val, 2); + svasrd_x(svbool_t_val, svint8_t_val, 2); + svasrd_x(svbool_t_val, svint16_t_val, 2); + svasrd_x(svbool_t_val, svint32_t_val, 2); + svasrd_x(svbool_t_val, svint64_t_val, 2); + svasrd_z(svbool_t_val, svint8_t_val, 2); + svasrd_z(svbool_t_val, svint16_t_val, 2); + svasrd_z(svbool_t_val, svint32_t_val, 2); + svasrd_z(svbool_t_val, svint64_t_val, 2); + svbic_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbrka_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_b_z(svbool_t_val, svbool_t_val); + svbrka_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_z(svbool_t_val, svbool_t_val); + svbrkb_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_b_z(svbool_t_val, svbool_t_val); + svbrkb_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_z(svbool_t_val, svbool_t_val); + svbrkn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_z(svbool_t_val, svbool_t_val, svbool_t_val); + svcadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svclasta(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, int8_t_val, svint8_t_val); + svclasta(svbool_t_val, int16_t_val, svint16_t_val); + svclasta(svbool_t_val, int32_t_val, svint32_t_val); + svclasta(svbool_t_val, int64_t_val, svint64_t_val); + svclasta(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclasta(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclasta_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclasta_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclasta_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclasta_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, int8_t_val, svint8_t_val); + svclastb(svbool_t_val, int16_t_val, svint16_t_val); + svclastb(svbool_t_val, int32_t_val, svint32_t_val); + svclastb(svbool_t_val, int64_t_val, svint64_t_val); + svclastb(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclastb_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclastb_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclastb_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclastb_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcls_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_s8_x(svbool_t_val, svint8_t_val); + svcls_s8_z(svbool_t_val, svint8_t_val); + svcls_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_s16_x(svbool_t_val, svint16_t_val); + svcls_s16_z(svbool_t_val, svint16_t_val); + svcls_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_s32_x(svbool_t_val, svint32_t_val); + svcls_s32_z(svbool_t_val, svint32_t_val); + svcls_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s64_x(svbool_t_val, svint64_t_val); + svcls_s64_z(svbool_t_val, svint64_t_val); + svcls_x(svbool_t_val, svint8_t_val); + svcls_x(svbool_t_val, svint16_t_val); + svcls_x(svbool_t_val, svint32_t_val); + svcls_x(svbool_t_val, svint64_t_val); + svcls_z(svbool_t_val, svint8_t_val); + svcls_z(svbool_t_val, svint16_t_val); + svcls_z(svbool_t_val, svint32_t_val); + svcls_z(svbool_t_val, svint64_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_s8_x(svbool_t_val, svint8_t_val); + svclz_s8_z(svbool_t_val, svint8_t_val); + svclz_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_s16_x(svbool_t_val, svint16_t_val); + svclz_s16_z(svbool_t_val, svint16_t_val); + svclz_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_s32_x(svbool_t_val, svint32_t_val); + svclz_s32_z(svbool_t_val, svint32_t_val); + svclz_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_s64_x(svbool_t_val, svint64_t_val); + svclz_s64_z(svbool_t_val, svint64_t_val); + svclz_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_u8_x(svbool_t_val, svuint8_t_val); + svclz_u8_z(svbool_t_val, svuint8_t_val); + svclz_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_u16_x(svbool_t_val, svuint16_t_val); + svclz_u16_z(svbool_t_val, svuint16_t_val); + svclz_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_u32_x(svbool_t_val, svuint32_t_val); + svclz_u32_z(svbool_t_val, svuint32_t_val); + svclz_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_u64_x(svbool_t_val, svuint64_t_val); + svclz_u64_z(svbool_t_val, svuint64_t_val); + svclz_x(svbool_t_val, svint8_t_val); + svclz_x(svbool_t_val, svint16_t_val); + svclz_x(svbool_t_val, svint32_t_val); + svclz_x(svbool_t_val, svint64_t_val); + svclz_x(svbool_t_val, svuint8_t_val); + svclz_x(svbool_t_val, svuint16_t_val); + svclz_x(svbool_t_val, svuint32_t_val); + svclz_x(svbool_t_val, svuint64_t_val); + svclz_z(svbool_t_val, svint8_t_val); + svclz_z(svbool_t_val, svint16_t_val); + svclz_z(svbool_t_val, svint32_t_val); + svclz_z(svbool_t_val, svint64_t_val); + svclz_z(svbool_t_val, svuint8_t_val); + svclz_z(svbool_t_val, svuint16_t_val); + svclz_z(svbool_t_val, svuint32_t_val); + svclz_z(svbool_t_val, svuint64_t_val); + svcmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmpeq(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpeq_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple(svbool_t_val, svint8_t_val, int8_t_val); + svcmple(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple(svbool_t_val, svint16_t_val, int16_t_val); + svcmple(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple(svbool_t_val, svint32_t_val, int32_t_val); + svcmple(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple(svbool_t_val, svint64_t_val, int64_t_val); + svcmple(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmple_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmple_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmple_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmple_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpne_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_s8_x(svbool_t_val, svint8_t_val); + svcnot_s8_z(svbool_t_val, svint8_t_val); + svcnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_s16_x(svbool_t_val, svint16_t_val); + svcnot_s16_z(svbool_t_val, svint16_t_val); + svcnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_s32_x(svbool_t_val, svint32_t_val); + svcnot_s32_z(svbool_t_val, svint32_t_val); + svcnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_s64_x(svbool_t_val, svint64_t_val); + svcnot_s64_z(svbool_t_val, svint64_t_val); + svcnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_u8_x(svbool_t_val, svuint8_t_val); + svcnot_u8_z(svbool_t_val, svuint8_t_val); + svcnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_u16_x(svbool_t_val, svuint16_t_val); + svcnot_u16_z(svbool_t_val, svuint16_t_val); + svcnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_u32_x(svbool_t_val, svuint32_t_val); + svcnot_u32_z(svbool_t_val, svuint32_t_val); + svcnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_u64_x(svbool_t_val, svuint64_t_val); + svcnot_u64_z(svbool_t_val, svuint64_t_val); + svcnot_x(svbool_t_val, svint8_t_val); + svcnot_x(svbool_t_val, svint16_t_val); + svcnot_x(svbool_t_val, svint32_t_val); + svcnot_x(svbool_t_val, svint64_t_val); + svcnot_x(svbool_t_val, svuint8_t_val); + svcnot_x(svbool_t_val, svuint16_t_val); + svcnot_x(svbool_t_val, svuint32_t_val); + svcnot_x(svbool_t_val, svuint64_t_val); + svcnot_z(svbool_t_val, svint8_t_val); + svcnot_z(svbool_t_val, svint16_t_val); + svcnot_z(svbool_t_val, svint32_t_val); + svcnot_z(svbool_t_val, svint64_t_val); + svcnot_z(svbool_t_val, svuint8_t_val); + svcnot_z(svbool_t_val, svuint16_t_val); + svcnot_z(svbool_t_val, svuint32_t_val); + svcnot_z(svbool_t_val, svuint64_t_val); + svcnt_bf16_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_bf16_x(svbool_t_val, svbfloat16_t_val); + svcnt_bf16_z(svbool_t_val, svbfloat16_t_val); + svcnt_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_f16_x(svbool_t_val, svfloat16_t_val); + svcnt_f16_z(svbool_t_val, svfloat16_t_val); + svcnt_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_f32_x(svbool_t_val, svfloat32_t_val); + svcnt_f32_z(svbool_t_val, svfloat32_t_val); + svcnt_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_f64_x(svbool_t_val, svfloat64_t_val); + svcnt_f64_z(svbool_t_val, svfloat64_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_s8_x(svbool_t_val, svint8_t_val); + svcnt_s8_z(svbool_t_val, svint8_t_val); + svcnt_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_s16_x(svbool_t_val, svint16_t_val); + svcnt_s16_z(svbool_t_val, svint16_t_val); + svcnt_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_s32_x(svbool_t_val, svint32_t_val); + svcnt_s32_z(svbool_t_val, svint32_t_val); + svcnt_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_s64_x(svbool_t_val, svint64_t_val); + svcnt_s64_z(svbool_t_val, svint64_t_val); + svcnt_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_u8_x(svbool_t_val, svuint8_t_val); + svcnt_u8_z(svbool_t_val, svuint8_t_val); + svcnt_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_u16_x(svbool_t_val, svuint16_t_val); + svcnt_u16_z(svbool_t_val, svuint16_t_val); + svcnt_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_u32_x(svbool_t_val, svuint32_t_val); + svcnt_u32_z(svbool_t_val, svuint32_t_val); + svcnt_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_u64_x(svbool_t_val, svuint64_t_val); + svcnt_u64_z(svbool_t_val, svuint64_t_val); + svcnt_x(svbool_t_val, svbfloat16_t_val); + svcnt_x(svbool_t_val, svfloat16_t_val); + svcnt_x(svbool_t_val, svfloat32_t_val); + svcnt_x(svbool_t_val, svfloat64_t_val); + svcnt_x(svbool_t_val, svint8_t_val); + svcnt_x(svbool_t_val, svint16_t_val); + svcnt_x(svbool_t_val, svint32_t_val); + svcnt_x(svbool_t_val, svint64_t_val); + svcnt_x(svbool_t_val, svuint8_t_val); + svcnt_x(svbool_t_val, svuint16_t_val); + svcnt_x(svbool_t_val, svuint32_t_val); + svcnt_x(svbool_t_val, svuint64_t_val); + svcnt_z(svbool_t_val, svbfloat16_t_val); + svcnt_z(svbool_t_val, svfloat16_t_val); + svcnt_z(svbool_t_val, svfloat32_t_val); + svcnt_z(svbool_t_val, svfloat64_t_val); + svcnt_z(svbool_t_val, svint8_t_val); + svcnt_z(svbool_t_val, svint16_t_val); + svcnt_z(svbool_t_val, svint32_t_val); + svcnt_z(svbool_t_val, svint64_t_val); + svcnt_z(svbool_t_val, svuint8_t_val); + svcnt_z(svbool_t_val, svuint16_t_val); + svcnt_z(svbool_t_val, svuint32_t_val); + svcnt_z(svbool_t_val, svuint64_t_val); + svcntb(); + svcntb_pat(SV_MUL3); + svcntd(); + svcntd_pat(SV_MUL3); + svcnth(); + svcnth_pat(SV_MUL3); + svcntp_b8(svbool_t_val, svbool_t_val); + svcntp_b16(svbool_t_val, svbool_t_val); + svcntp_b32(svbool_t_val, svbool_t_val); + svcntp_b64(svbool_t_val, svbool_t_val); + svcntw(); + svcntw_pat(SV_MUL3); + svcreate2(svbfloat16_t_val, svbfloat16_t_val); + svcreate2(svfloat16_t_val, svfloat16_t_val); + svcreate2(svfloat32_t_val, svfloat32_t_val); + svcreate2(svfloat64_t_val, svfloat64_t_val); + svcreate2(svint8_t_val, svint8_t_val); + svcreate2(svint16_t_val, svint16_t_val); + svcreate2(svint32_t_val, svint32_t_val); + svcreate2(svint64_t_val, svint64_t_val); + svcreate2(svmfloat8_t_val, svmfloat8_t_val); + svcreate2(svuint8_t_val, svuint8_t_val); + svcreate2(svuint16_t_val, svuint16_t_val); + svcreate2(svuint32_t_val, svuint32_t_val); + svcreate2(svuint64_t_val, svuint64_t_val); + svcreate2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svcreate2_f16(svfloat16_t_val, svfloat16_t_val); + svcreate2_f32(svfloat32_t_val, svfloat32_t_val); + svcreate2_f64(svfloat64_t_val, svfloat64_t_val); + svcreate2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svcreate2_s8(svint8_t_val, svint8_t_val); + svcreate2_s16(svint16_t_val, svint16_t_val); + svcreate2_s32(svint32_t_val, svint32_t_val); + svcreate2_s64(svint64_t_val, svint64_t_val); + svcreate2_u8(svuint8_t_val, svuint8_t_val); + svcreate2_u16(svuint16_t_val, svuint16_t_val); + svcreate2_u32(svuint32_t_val, svuint32_t_val); + svcreate2_u64(svuint64_t_val, svuint64_t_val); + svcreate3(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate3_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4_s8(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4_s16(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4_s32(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4_s64(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcvt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_f64_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_s16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_s16_x(svbool_t_val, svint16_t_val); + svcvt_f16_s16_z(svbool_t_val, svint16_t_val); + svcvt_f16_s32_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_s32_x(svbool_t_val, svint32_t_val); + svcvt_f16_s32_z(svbool_t_val, svint32_t_val); + svcvt_f16_s64_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_s64_x(svbool_t_val, svint64_t_val); + svcvt_f16_s64_z(svbool_t_val, svint64_t_val); + svcvt_f16_u16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_u16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_u16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_u32_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f16_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f16_u64_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f16_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f16_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_x(svbool_t_val, svint16_t_val); + svcvt_f16_x(svbool_t_val, svint32_t_val); + svcvt_f16_x(svbool_t_val, svint64_t_val); + svcvt_f16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_x(svbool_t_val, svuint32_t_val); + svcvt_f16_x(svbool_t_val, svuint64_t_val); + svcvt_f16_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_z(svbool_t_val, svint16_t_val); + svcvt_f16_z(svbool_t_val, svint32_t_val); + svcvt_f16_z(svbool_t_val, svint64_t_val); + svcvt_f16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_z(svbool_t_val, svuint32_t_val); + svcvt_f16_z(svbool_t_val, svuint64_t_val); + svcvt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_s32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_s32_x(svbool_t_val, svint32_t_val); + svcvt_f32_s32_z(svbool_t_val, svint32_t_val); + svcvt_f32_s64_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_s64_x(svbool_t_val, svint64_t_val); + svcvt_f32_s64_z(svbool_t_val, svint64_t_val); + svcvt_f32_u32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_u64_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f32_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f32_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_x(svbool_t_val, svint32_t_val); + svcvt_f32_x(svbool_t_val, svint64_t_val); + svcvt_f32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_x(svbool_t_val, svuint64_t_val); + svcvt_f32_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_z(svbool_t_val, svint32_t_val); + svcvt_f32_z(svbool_t_val, svint64_t_val); + svcvt_f32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_z(svbool_t_val, svuint64_t_val); + svcvt_f64_f16_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_s32_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_s32_x(svbool_t_val, svint32_t_val); + svcvt_f64_s32_z(svbool_t_val, svint32_t_val); + svcvt_f64_s64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_s64_x(svbool_t_val, svint64_t_val); + svcvt_f64_s64_z(svbool_t_val, svint64_t_val); + svcvt_f64_u32_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f64_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f64_u64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f64_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_x(svbool_t_val, svint32_t_val); + svcvt_f64_x(svbool_t_val, svint64_t_val); + svcvt_f64_x(svbool_t_val, svuint32_t_val); + svcvt_f64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_z(svbool_t_val, svint32_t_val); + svcvt_f64_z(svbool_t_val, svint64_t_val); + svcvt_f64_z(svbool_t_val, svuint32_t_val); + svcvt_f64_z(svbool_t_val, svuint64_t_val); + svcvt_s16_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_f64_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_f16_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_f32_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_z(svbool_t_val, svfloat64_t_val); + svcvt_u16_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_f64_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_f16_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_f32_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_z(svbool_t_val, svfloat64_t_val); + svdiv_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdot(svint32_t_val, svint8_t_val, int8_t_val); + svdot(svint32_t_val, svint8_t_val, svint8_t_val); + svdot(svint64_t_val, svint16_t_val, int16_t_val); + svdot(svint64_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdot(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_n_s32(svint32_t_val, svint8_t_val, int8_t_val); + svdot_n_s64(svint64_t_val, svint16_t_val, int16_t_val); + svdot_n_u32(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot_n_u64(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_s32(svint32_t_val, svint8_t_val, svint8_t_val); + svdot_s64(svint64_t_val, svint16_t_val, svint16_t_val); + svdot_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdup_b8(bool_val); + svdup_b16(bool_val); + svdup_b32(bool_val); + svdup_b64(bool_val); + svdup_bf16(bfloat16_t_val); + svdup_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_f16(float16_t_val); + svdup_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_f16_x(svbool_t_val, float16_t_val); + svdup_f16_z(svbool_t_val, float16_t_val); + svdup_f32(float32_t_val); + svdup_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_f32_x(svbool_t_val, float32_t_val); + svdup_f32_z(svbool_t_val, float32_t_val); + svdup_f64(float64_t_val); + svdup_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_f64_x(svbool_t_val, float64_t_val); + svdup_f64_z(svbool_t_val, float64_t_val); + svdup_lane(svbfloat16_t_val, uint16_t_val); + svdup_lane(svfloat16_t_val, uint16_t_val); + svdup_lane(svfloat32_t_val, uint32_t_val); + svdup_lane(svfloat64_t_val, uint64_t_val); + svdup_lane(svint8_t_val, uint8_t_val); + svdup_lane(svint16_t_val, uint16_t_val); + svdup_lane(svint32_t_val, uint32_t_val); + svdup_lane(svint64_t_val, uint64_t_val); + svdup_lane(svuint8_t_val, uint8_t_val); + svdup_lane(svuint16_t_val, uint16_t_val); + svdup_lane(svuint32_t_val, uint32_t_val); + svdup_lane(svuint64_t_val, uint64_t_val); + svdup_lane_bf16(svbfloat16_t_val, uint16_t_val); + svdup_lane_f16(svfloat16_t_val, uint16_t_val); + svdup_lane_f32(svfloat32_t_val, uint32_t_val); + svdup_lane_f64(svfloat64_t_val, uint64_t_val); + svdup_lane_s8(svint8_t_val, uint8_t_val); + svdup_lane_s16(svint16_t_val, uint16_t_val); + svdup_lane_s32(svint32_t_val, uint32_t_val); + svdup_lane_s64(svint64_t_val, uint64_t_val); + svdup_lane_u8(svuint8_t_val, uint8_t_val); + svdup_lane_u16(svuint16_t_val, uint16_t_val); + svdup_lane_u32(svuint32_t_val, uint32_t_val); + svdup_lane_u64(svuint64_t_val, uint64_t_val); + svdup_n_b8(bool_val); + svdup_n_b16(bool_val); + svdup_n_b32(bool_val); + svdup_n_b64(bool_val); + svdup_n_bf16(bfloat16_t_val); + svdup_n_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_n_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_n_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_n_f16(float16_t_val); + svdup_n_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_n_f16_x(svbool_t_val, float16_t_val); + svdup_n_f16_z(svbool_t_val, float16_t_val); + svdup_n_f32(float32_t_val); + svdup_n_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_n_f32_x(svbool_t_val, float32_t_val); + svdup_n_f32_z(svbool_t_val, float32_t_val); + svdup_n_f64(float64_t_val); + svdup_n_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_n_f64_x(svbool_t_val, float64_t_val); + svdup_n_f64_z(svbool_t_val, float64_t_val); + svdup_n_s8(int8_t_val); + svdup_n_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_n_s8_x(svbool_t_val, int8_t_val); + svdup_n_s8_z(svbool_t_val, int8_t_val); + svdup_n_s16(int16_t_val); + svdup_n_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_n_s16_x(svbool_t_val, int16_t_val); + svdup_n_s16_z(svbool_t_val, int16_t_val); + svdup_n_s32(int32_t_val); + svdup_n_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_n_s32_x(svbool_t_val, int32_t_val); + svdup_n_s32_z(svbool_t_val, int32_t_val); + svdup_n_s64(int64_t_val); + svdup_n_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_n_s64_x(svbool_t_val, int64_t_val); + svdup_n_s64_z(svbool_t_val, int64_t_val); + svdup_n_u8(uint8_t_val); + svdup_n_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_n_u8_x(svbool_t_val, uint8_t_val); + svdup_n_u8_z(svbool_t_val, uint8_t_val); + svdup_n_u16(uint16_t_val); + svdup_n_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_n_u16_x(svbool_t_val, uint16_t_val); + svdup_n_u16_z(svbool_t_val, uint16_t_val); + svdup_n_u32(uint32_t_val); + svdup_n_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_n_u32_x(svbool_t_val, uint32_t_val); + svdup_n_u32_z(svbool_t_val, uint32_t_val); + svdup_n_u64(uint64_t_val); + svdup_n_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_n_u64_x(svbool_t_val, uint64_t_val); + svdup_n_u64_z(svbool_t_val, uint64_t_val); + svdup_s8(int8_t_val); + svdup_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_s8_x(svbool_t_val, int8_t_val); + svdup_s8_z(svbool_t_val, int8_t_val); + svdup_s16(int16_t_val); + svdup_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_s16_x(svbool_t_val, int16_t_val); + svdup_s16_z(svbool_t_val, int16_t_val); + svdup_s32(int32_t_val); + svdup_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_s32_x(svbool_t_val, int32_t_val); + svdup_s32_z(svbool_t_val, int32_t_val); + svdup_s64(int64_t_val); + svdup_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_s64_x(svbool_t_val, int64_t_val); + svdup_s64_z(svbool_t_val, int64_t_val); + svdup_u8(uint8_t_val); + svdup_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_u8_x(svbool_t_val, uint8_t_val); + svdup_u8_z(svbool_t_val, uint8_t_val); + svdup_u16(uint16_t_val); + svdup_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_u16_x(svbool_t_val, uint16_t_val); + svdup_u16_z(svbool_t_val, uint16_t_val); + svdup_u32(uint32_t_val); + svdup_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_u32_x(svbool_t_val, uint32_t_val); + svdup_u32_z(svbool_t_val, uint32_t_val); + svdup_u64(uint64_t_val); + svdup_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_u64_x(svbool_t_val, uint64_t_val); + svdup_u64_z(svbool_t_val, uint64_t_val); + svdupq_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_b64(bool_val, bool_val); + svdupq_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_f64(float64_t_val, float64_t_val); + svdupq_lane(svbfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat32_t_val, uint64_t_val); + svdupq_lane(svfloat64_t_val, uint64_t_val); + svdupq_lane(svint8_t_val, uint64_t_val); + svdupq_lane(svint16_t_val, uint64_t_val); + svdupq_lane(svint32_t_val, uint64_t_val); + svdupq_lane(svint64_t_val, uint64_t_val); + svdupq_lane(svuint8_t_val, uint64_t_val); + svdupq_lane(svuint16_t_val, uint64_t_val); + svdupq_lane(svuint32_t_val, uint64_t_val); + svdupq_lane(svuint64_t_val, uint64_t_val); + svdupq_lane_bf16(svbfloat16_t_val, uint64_t_val); + svdupq_lane_f16(svfloat16_t_val, uint64_t_val); + svdupq_lane_f32(svfloat32_t_val, uint64_t_val); + svdupq_lane_f64(svfloat64_t_val, uint64_t_val); + svdupq_lane_s8(svint8_t_val, uint64_t_val); + svdupq_lane_s16(svint16_t_val, uint64_t_val); + svdupq_lane_s32(svint32_t_val, uint64_t_val); + svdupq_lane_s64(svint64_t_val, uint64_t_val); + svdupq_lane_u8(svuint8_t_val, uint64_t_val); + svdupq_lane_u16(svuint16_t_val, uint64_t_val); + svdupq_lane_u32(svuint32_t_val, uint64_t_val); + svdupq_lane_u64(svuint64_t_val, uint64_t_val); + svdupq_n_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_n_b64(bool_val, bool_val); + svdupq_n_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_n_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_n_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_n_f64(float64_t_val, float64_t_val); + svdupq_n_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_n_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_n_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_n_s64(int64_t_val, int64_t_val); + svdupq_n_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_n_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_n_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_n_u64(uint64_t_val, uint64_t_val); + svdupq_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_s64(int64_t_val, int64_t_val); + svdupq_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_u64(uint64_t_val, uint64_t_val); + sveor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveorv(svbool_t_val, svint8_t_val); + sveorv(svbool_t_val, svint16_t_val); + sveorv(svbool_t_val, svint32_t_val); + sveorv(svbool_t_val, svint64_t_val); + sveorv(svbool_t_val, svuint8_t_val); + sveorv(svbool_t_val, svuint16_t_val); + sveorv(svbool_t_val, svuint32_t_val); + sveorv(svbool_t_val, svuint64_t_val); + sveorv_s8(svbool_t_val, svint8_t_val); + sveorv_s16(svbool_t_val, svint16_t_val); + sveorv_s32(svbool_t_val, svint32_t_val); + sveorv_s64(svbool_t_val, svint64_t_val); + sveorv_u8(svbool_t_val, svuint8_t_val); + sveorv_u16(svbool_t_val, svuint16_t_val); + sveorv_u32(svbool_t_val, svuint32_t_val); + sveorv_u64(svbool_t_val, svuint64_t_val); + svext(svbfloat16_t_val, svbfloat16_t_val, 2); + svext(svfloat16_t_val, svfloat16_t_val, 2); + svext(svfloat32_t_val, svfloat32_t_val, 2); + svext(svfloat64_t_val, svfloat64_t_val, 2); + svext(svint8_t_val, svint8_t_val, 2); + svext(svint16_t_val, svint16_t_val, 2); + svext(svint32_t_val, svint32_t_val, 2); + svext(svint64_t_val, svint64_t_val, 2); + svext(svuint8_t_val, svuint8_t_val, 2); + svext(svuint16_t_val, svuint16_t_val, 2); + svext(svuint32_t_val, svuint32_t_val, 2); + svext(svuint64_t_val, svuint64_t_val, 2); + svext_bf16(svbfloat16_t_val, svbfloat16_t_val, 2); + svext_f16(svfloat16_t_val, svfloat16_t_val, 2); + svext_f32(svfloat32_t_val, svfloat32_t_val, 2); + svext_f64(svfloat64_t_val, svfloat64_t_val, 2); + svext_s8(svint8_t_val, svint8_t_val, 2); + svext_s16(svint16_t_val, svint16_t_val, 2); + svext_s32(svint32_t_val, svint32_t_val, 2); + svext_s64(svint64_t_val, svint64_t_val, 2); + svext_u8(svuint8_t_val, svuint8_t_val, 2); + svext_u16(svuint16_t_val, svuint16_t_val, 2); + svext_u32(svuint32_t_val, svuint32_t_val, 2); + svext_u64(svuint64_t_val, svuint64_t_val, 2); + svextb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_s16_x(svbool_t_val, svint16_t_val); + svextb_s16_z(svbool_t_val, svint16_t_val); + svextb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_s32_x(svbool_t_val, svint32_t_val); + svextb_s32_z(svbool_t_val, svint32_t_val); + svextb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_s64_x(svbool_t_val, svint64_t_val); + svextb_s64_z(svbool_t_val, svint64_t_val); + svextb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_u16_x(svbool_t_val, svuint16_t_val); + svextb_u16_z(svbool_t_val, svuint16_t_val); + svextb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_u32_x(svbool_t_val, svuint32_t_val); + svextb_u32_z(svbool_t_val, svuint32_t_val); + svextb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_u64_x(svbool_t_val, svuint64_t_val); + svextb_u64_z(svbool_t_val, svuint64_t_val); + svextb_x(svbool_t_val, svint16_t_val); + svextb_x(svbool_t_val, svint32_t_val); + svextb_x(svbool_t_val, svint64_t_val); + svextb_x(svbool_t_val, svuint16_t_val); + svextb_x(svbool_t_val, svuint32_t_val); + svextb_x(svbool_t_val, svuint64_t_val); + svextb_z(svbool_t_val, svint16_t_val); + svextb_z(svbool_t_val, svint32_t_val); + svextb_z(svbool_t_val, svint64_t_val); + svextb_z(svbool_t_val, svuint16_t_val); + svextb_z(svbool_t_val, svuint32_t_val); + svextb_z(svbool_t_val, svuint64_t_val); + svexth_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_s32_x(svbool_t_val, svint32_t_val); + svexth_s32_z(svbool_t_val, svint32_t_val); + svexth_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_s64_x(svbool_t_val, svint64_t_val); + svexth_s64_z(svbool_t_val, svint64_t_val); + svexth_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_u32_x(svbool_t_val, svuint32_t_val); + svexth_u32_z(svbool_t_val, svuint32_t_val); + svexth_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_u64_x(svbool_t_val, svuint64_t_val); + svexth_u64_z(svbool_t_val, svuint64_t_val); + svexth_x(svbool_t_val, svint32_t_val); + svexth_x(svbool_t_val, svint64_t_val); + svexth_x(svbool_t_val, svuint32_t_val); + svexth_x(svbool_t_val, svuint64_t_val); + svexth_z(svbool_t_val, svint32_t_val); + svexth_z(svbool_t_val, svint64_t_val); + svexth_z(svbool_t_val, svuint32_t_val); + svexth_z(svbool_t_val, svuint64_t_val); + svextw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_s64_x(svbool_t_val, svint64_t_val); + svextw_s64_z(svbool_t_val, svint64_t_val); + svextw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_u64_x(svbool_t_val, svuint64_t_val); + svextw_u64_z(svbool_t_val, svuint64_t_val); + svextw_x(svbool_t_val, svint64_t_val); + svextw_x(svbool_t_val, svuint64_t_val); + svextw_z(svbool_t_val, svint64_t_val); + svextw_z(svbool_t_val, svuint64_t_val); + svget2(svbfloat16x2_t_val, 1); + svget2(svfloat16x2_t_val, 1); + svget2(svfloat32x2_t_val, 1); + svget2(svfloat64x2_t_val, 1); + svget2(svint8x2_t_val, 1); + svget2(svint16x2_t_val, 1); + svget2(svint32x2_t_val, 1); + svget2(svint64x2_t_val, 1); + svget2(svmfloat8x2_t_val, 1); + svget2(svuint8x2_t_val, 1); + svget2(svuint16x2_t_val, 1); + svget2(svuint32x2_t_val, 1); + svget2(svuint64x2_t_val, 1); + svget2_bf16(svbfloat16x2_t_val, 1); + svget2_f16(svfloat16x2_t_val, 1); + svget2_f32(svfloat32x2_t_val, 1); + svget2_f64(svfloat64x2_t_val, 1); + svget2_mf8(svmfloat8x2_t_val, 1); + svget2_s8(svint8x2_t_val, 1); + svget2_s16(svint16x2_t_val, 1); + svget2_s32(svint32x2_t_val, 1); + svget2_s64(svint64x2_t_val, 1); + svget2_u8(svuint8x2_t_val, 1); + svget2_u16(svuint16x2_t_val, 1); + svget2_u32(svuint32x2_t_val, 1); + svget2_u64(svuint64x2_t_val, 1); + svget3(svbfloat16x3_t_val, 2); + svget3(svfloat16x3_t_val, 2); + svget3(svfloat32x3_t_val, 2); + svget3(svfloat64x3_t_val, 2); + svget3(svint8x3_t_val, 2); + svget3(svint16x3_t_val, 2); + svget3(svint32x3_t_val, 2); + svget3(svint64x3_t_val, 2); + svget3(svmfloat8x3_t_val, 2); + svget3(svuint8x3_t_val, 2); + svget3(svuint16x3_t_val, 2); + svget3(svuint32x3_t_val, 2); + svget3(svuint64x3_t_val, 2); + svget3_bf16(svbfloat16x3_t_val, 2); + svget3_f16(svfloat16x3_t_val, 2); + svget3_f32(svfloat32x3_t_val, 2); + svget3_f64(svfloat64x3_t_val, 2); + svget3_mf8(svmfloat8x3_t_val, 2); + svget3_s8(svint8x3_t_val, 2); + svget3_s16(svint16x3_t_val, 2); + svget3_s32(svint32x3_t_val, 2); + svget3_s64(svint64x3_t_val, 2); + svget3_u8(svuint8x3_t_val, 2); + svget3_u16(svuint16x3_t_val, 2); + svget3_u32(svuint32x3_t_val, 2); + svget3_u64(svuint64x3_t_val, 2); + svget4(svbfloat16x4_t_val, 2); + svget4(svfloat16x4_t_val, 2); + svget4(svfloat32x4_t_val, 2); + svget4(svfloat64x4_t_val, 2); + svget4(svint8x4_t_val, 2); + svget4(svint16x4_t_val, 2); + svget4(svint32x4_t_val, 2); + svget4(svint64x4_t_val, 2); + svget4(svmfloat8x4_t_val, 2); + svget4(svuint8x4_t_val, 2); + svget4(svuint16x4_t_val, 2); + svget4(svuint32x4_t_val, 2); + svget4(svuint64x4_t_val, 2); + svget4_bf16(svbfloat16x4_t_val, 2); + svget4_f16(svfloat16x4_t_val, 2); + svget4_f32(svfloat32x4_t_val, 2); + svget4_f64(svfloat64x4_t_val, 2); + svget4_mf8(svmfloat8x4_t_val, 2); + svget4_s8(svint8x4_t_val, 2); + svget4_s16(svint16x4_t_val, 2); + svget4_s32(svint32x4_t_val, 2); + svget4_s64(svint64x4_t_val, 2); + svget4_u8(svuint8x4_t_val, 2); + svget4_u16(svuint16x4_t_val, 2); + svget4_u32(svuint32x4_t_val, 2); + svget4_u64(svuint64x4_t_val, 2); + svindex_s8(int8_t_val, int8_t_val); + svindex_s16(int16_t_val, int16_t_val); + svindex_s32(int32_t_val, int32_t_val); + svindex_s64(int64_t_val, int64_t_val); + svindex_u8(uint8_t_val, uint8_t_val); + svindex_u16(uint16_t_val, uint16_t_val); + svindex_u32(uint32_t_val, uint32_t_val); + svindex_u64(uint64_t_val, uint64_t_val); + svinsr(svbfloat16_t_val, bfloat16_t_val); + svinsr(svfloat16_t_val, float16_t_val); + svinsr(svfloat32_t_val, float32_t_val); + svinsr(svfloat64_t_val, float64_t_val); + svinsr(svint8_t_val, int8_t_val); + svinsr(svint16_t_val, int16_t_val); + svinsr(svint32_t_val, int32_t_val); + svinsr(svint64_t_val, int64_t_val); + svinsr(svuint8_t_val, uint8_t_val); + svinsr(svuint16_t_val, uint16_t_val); + svinsr(svuint32_t_val, uint32_t_val); + svinsr(svuint64_t_val, uint64_t_val); + svinsr_n_bf16(svbfloat16_t_val, bfloat16_t_val); + svinsr_n_f16(svfloat16_t_val, float16_t_val); + svinsr_n_f32(svfloat32_t_val, float32_t_val); + svinsr_n_f64(svfloat64_t_val, float64_t_val); + svinsr_n_s8(svint8_t_val, int8_t_val); + svinsr_n_s16(svint16_t_val, int16_t_val); + svinsr_n_s32(svint32_t_val, int32_t_val); + svinsr_n_s64(svint64_t_val, int64_t_val); + svinsr_n_u8(svuint8_t_val, uint8_t_val); + svinsr_n_u16(svuint16_t_val, uint16_t_val); + svinsr_n_u32(svuint32_t_val, uint32_t_val); + svinsr_n_u64(svuint64_t_val, uint64_t_val); + svlasta(svbool_t_val, svbfloat16_t_val); + svlasta(svbool_t_val, svfloat16_t_val); + svlasta(svbool_t_val, svfloat32_t_val); + svlasta(svbool_t_val, svfloat64_t_val); + svlasta(svbool_t_val, svint8_t_val); + svlasta(svbool_t_val, svint16_t_val); + svlasta(svbool_t_val, svint32_t_val); + svlasta(svbool_t_val, svint64_t_val); + svlasta(svbool_t_val, svuint8_t_val); + svlasta(svbool_t_val, svuint16_t_val); + svlasta(svbool_t_val, svuint32_t_val); + svlasta(svbool_t_val, svuint64_t_val); + svlasta_bf16(svbool_t_val, svbfloat16_t_val); + svlasta_f16(svbool_t_val, svfloat16_t_val); + svlasta_f32(svbool_t_val, svfloat32_t_val); + svlasta_f64(svbool_t_val, svfloat64_t_val); + svlasta_s8(svbool_t_val, svint8_t_val); + svlasta_s16(svbool_t_val, svint16_t_val); + svlasta_s32(svbool_t_val, svint32_t_val); + svlasta_s64(svbool_t_val, svint64_t_val); + svlasta_u8(svbool_t_val, svuint8_t_val); + svlasta_u16(svbool_t_val, svuint16_t_val); + svlasta_u32(svbool_t_val, svuint32_t_val); + svlasta_u64(svbool_t_val, svuint64_t_val); + svlastb(svbool_t_val, svbfloat16_t_val); + svlastb(svbool_t_val, svfloat16_t_val); + svlastb(svbool_t_val, svfloat32_t_val); + svlastb(svbool_t_val, svfloat64_t_val); + svlastb(svbool_t_val, svint8_t_val); + svlastb(svbool_t_val, svint16_t_val); + svlastb(svbool_t_val, svint32_t_val); + svlastb(svbool_t_val, svint64_t_val); + svlastb(svbool_t_val, svuint8_t_val); + svlastb(svbool_t_val, svuint16_t_val); + svlastb(svbool_t_val, svuint32_t_val); + svlastb(svbool_t_val, svuint64_t_val); + svlastb_bf16(svbool_t_val, svbfloat16_t_val); + svlastb_f16(svbool_t_val, svfloat16_t_val); + svlastb_f32(svbool_t_val, svfloat32_t_val); + svlastb_f64(svbool_t_val, svfloat64_t_val); + svlastb_s8(svbool_t_val, svint8_t_val); + svlastb_s16(svbool_t_val, svint16_t_val); + svlastb_s32(svbool_t_val, svint32_t_val); + svlastb_s64(svbool_t_val, svint64_t_val); + svlastb_u8(svbool_t_val, svuint8_t_val); + svlastb_u16(svbool_t_val, svuint16_t_val); + svlastb_u32(svbool_t_val, svuint32_t_val); + svlastb_u64(svbool_t_val, svuint64_t_val); + svld1(svbool_t_val, bfloat16_t_ptr_val); + svld1(svbool_t_val, float16_t_ptr_val); + svld1(svbool_t_val, float32_t_ptr_val); + svld1(svbool_t_val, float64_t_ptr_val); + svld1(svbool_t_val, int8_t_ptr_val); + svld1(svbool_t_val, int16_t_ptr_val); + svld1(svbool_t_val, int32_t_ptr_val); + svld1(svbool_t_val, int64_t_ptr_val); + svld1(svbool_t_val, mfloat8_t_ptr_val); + svld1(svbool_t_val, uint8_t_ptr_val); + svld1(svbool_t_val, uint16_t_ptr_val); + svld1(svbool_t_val, uint32_t_ptr_val); + svld1(svbool_t_val, uint64_t_ptr_val); + svld1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1_f16(svbool_t_val, float16_t_ptr_val); + svld1_f32(svbool_t_val, float32_t_ptr_val); + svld1_f64(svbool_t_val, float64_t_ptr_val); + svld1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1_s8(svbool_t_val, int8_t_ptr_val); + svld1_s16(svbool_t_val, int16_t_ptr_val); + svld1_s32(svbool_t_val, int32_t_ptr_val); + svld1_s64(svbool_t_val, int64_t_ptr_val); + svld1_u8(svbool_t_val, uint8_t_ptr_val); + svld1_u16(svbool_t_val, uint16_t_ptr_val); + svld1_u32(svbool_t_val, uint32_t_ptr_val); + svld1_u64(svbool_t_val, uint64_t_ptr_val); + svld1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1rq(svbool_t_val, bfloat16_t_ptr_val); + svld1rq(svbool_t_val, float16_t_ptr_val); + svld1rq(svbool_t_val, float32_t_ptr_val); + svld1rq(svbool_t_val, float64_t_ptr_val); + svld1rq(svbool_t_val, int8_t_ptr_val); + svld1rq(svbool_t_val, int16_t_ptr_val); + svld1rq(svbool_t_val, int32_t_ptr_val); + svld1rq(svbool_t_val, int64_t_ptr_val); + svld1rq(svbool_t_val, mfloat8_t_ptr_val); + svld1rq(svbool_t_val, uint8_t_ptr_val); + svld1rq(svbool_t_val, uint16_t_ptr_val); + svld1rq(svbool_t_val, uint32_t_ptr_val); + svld1rq(svbool_t_val, uint64_t_ptr_val); + svld1rq_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1rq_f16(svbool_t_val, float16_t_ptr_val); + svld1rq_f32(svbool_t_val, float32_t_ptr_val); + svld1rq_f64(svbool_t_val, float64_t_ptr_val); + svld1rq_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1rq_s8(svbool_t_val, int8_t_ptr_val); + svld1rq_s16(svbool_t_val, int16_t_ptr_val); + svld1rq_s32(svbool_t_val, int32_t_ptr_val); + svld1rq_s64(svbool_t_val, int64_t_ptr_val); + svld1rq_u8(svbool_t_val, uint8_t_ptr_val); + svld1rq_u16(svbool_t_val, uint16_t_ptr_val); + svld1rq_u32(svbool_t_val, uint32_t_ptr_val); + svld1rq_u64(svbool_t_val, uint64_t_ptr_val); + svld1sb_s16(svbool_t_val, int8_t_ptr_val); + svld1sb_s32(svbool_t_val, int8_t_ptr_val); + svld1sb_s64(svbool_t_val, int8_t_ptr_val); + svld1sb_u16(svbool_t_val, int8_t_ptr_val); + svld1sb_u32(svbool_t_val, int8_t_ptr_val); + svld1sb_u64(svbool_t_val, int8_t_ptr_val); + svld1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sh_s32(svbool_t_val, int16_t_ptr_val); + svld1sh_s64(svbool_t_val, int16_t_ptr_val); + svld1sh_u32(svbool_t_val, int16_t_ptr_val); + svld1sh_u64(svbool_t_val, int16_t_ptr_val); + svld1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sw_s64(svbool_t_val, int32_t_ptr_val); + svld1sw_u64(svbool_t_val, int32_t_ptr_val); + svld1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1ub_s16(svbool_t_val, uint8_t_ptr_val); + svld1ub_s32(svbool_t_val, uint8_t_ptr_val); + svld1ub_s64(svbool_t_val, uint8_t_ptr_val); + svld1ub_u16(svbool_t_val, uint8_t_ptr_val); + svld1ub_u32(svbool_t_val, uint8_t_ptr_val); + svld1ub_u64(svbool_t_val, uint8_t_ptr_val); + svld1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1uh_s32(svbool_t_val, uint16_t_ptr_val); + svld1uh_s64(svbool_t_val, uint16_t_ptr_val); + svld1uh_u32(svbool_t_val, uint16_t_ptr_val); + svld1uh_u64(svbool_t_val, uint16_t_ptr_val); + svld1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uw_s64(svbool_t_val, uint32_t_ptr_val); + svld1uw_u64(svbool_t_val, uint32_t_ptr_val); + svld1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2(svbool_t_val, bfloat16_t_ptr_val); + svld2(svbool_t_val, float16_t_ptr_val); + svld2(svbool_t_val, float32_t_ptr_val); + svld2(svbool_t_val, float64_t_ptr_val); + svld2(svbool_t_val, int8_t_ptr_val); + svld2(svbool_t_val, int16_t_ptr_val); + svld2(svbool_t_val, int32_t_ptr_val); + svld2(svbool_t_val, int64_t_ptr_val); + svld2(svbool_t_val, mfloat8_t_ptr_val); + svld2(svbool_t_val, uint8_t_ptr_val); + svld2(svbool_t_val, uint16_t_ptr_val); + svld2(svbool_t_val, uint32_t_ptr_val); + svld2(svbool_t_val, uint64_t_ptr_val); + svld2_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2_f16(svbool_t_val, float16_t_ptr_val); + svld2_f32(svbool_t_val, float32_t_ptr_val); + svld2_f64(svbool_t_val, float64_t_ptr_val); + svld2_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2_s8(svbool_t_val, int8_t_ptr_val); + svld2_s16(svbool_t_val, int16_t_ptr_val); + svld2_s32(svbool_t_val, int32_t_ptr_val); + svld2_s64(svbool_t_val, int64_t_ptr_val); + svld2_u8(svbool_t_val, uint8_t_ptr_val); + svld2_u16(svbool_t_val, uint16_t_ptr_val); + svld2_u32(svbool_t_val, uint32_t_ptr_val); + svld2_u64(svbool_t_val, uint64_t_ptr_val); + svld2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3(svbool_t_val, bfloat16_t_ptr_val); + svld3(svbool_t_val, float16_t_ptr_val); + svld3(svbool_t_val, float32_t_ptr_val); + svld3(svbool_t_val, float64_t_ptr_val); + svld3(svbool_t_val, int8_t_ptr_val); + svld3(svbool_t_val, int16_t_ptr_val); + svld3(svbool_t_val, int32_t_ptr_val); + svld3(svbool_t_val, int64_t_ptr_val); + svld3(svbool_t_val, mfloat8_t_ptr_val); + svld3(svbool_t_val, uint8_t_ptr_val); + svld3(svbool_t_val, uint16_t_ptr_val); + svld3(svbool_t_val, uint32_t_ptr_val); + svld3(svbool_t_val, uint64_t_ptr_val); + svld3_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3_f16(svbool_t_val, float16_t_ptr_val); + svld3_f32(svbool_t_val, float32_t_ptr_val); + svld3_f64(svbool_t_val, float64_t_ptr_val); + svld3_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3_s8(svbool_t_val, int8_t_ptr_val); + svld3_s16(svbool_t_val, int16_t_ptr_val); + svld3_s32(svbool_t_val, int32_t_ptr_val); + svld3_s64(svbool_t_val, int64_t_ptr_val); + svld3_u8(svbool_t_val, uint8_t_ptr_val); + svld3_u16(svbool_t_val, uint16_t_ptr_val); + svld3_u32(svbool_t_val, uint32_t_ptr_val); + svld3_u64(svbool_t_val, uint64_t_ptr_val); + svld3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4(svbool_t_val, bfloat16_t_ptr_val); + svld4(svbool_t_val, float16_t_ptr_val); + svld4(svbool_t_val, float32_t_ptr_val); + svld4(svbool_t_val, float64_t_ptr_val); + svld4(svbool_t_val, int8_t_ptr_val); + svld4(svbool_t_val, int16_t_ptr_val); + svld4(svbool_t_val, int32_t_ptr_val); + svld4(svbool_t_val, int64_t_ptr_val); + svld4(svbool_t_val, mfloat8_t_ptr_val); + svld4(svbool_t_val, uint8_t_ptr_val); + svld4(svbool_t_val, uint16_t_ptr_val); + svld4(svbool_t_val, uint32_t_ptr_val); + svld4(svbool_t_val, uint64_t_ptr_val); + svld4_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4_f16(svbool_t_val, float16_t_ptr_val); + svld4_f32(svbool_t_val, float32_t_ptr_val); + svld4_f64(svbool_t_val, float64_t_ptr_val); + svld4_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4_s8(svbool_t_val, int8_t_ptr_val); + svld4_s16(svbool_t_val, int16_t_ptr_val); + svld4_s32(svbool_t_val, int32_t_ptr_val); + svld4_s64(svbool_t_val, int64_t_ptr_val); + svld4_u8(svbool_t_val, uint8_t_ptr_val); + svld4_u16(svbool_t_val, uint16_t_ptr_val); + svld4_u32(svbool_t_val, uint32_t_ptr_val); + svld4_u64(svbool_t_val, uint64_t_ptr_val); + svld4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1(svbool_t_val, bfloat16_t_ptr_val); + svldnt1(svbool_t_val, float16_t_ptr_val); + svldnt1(svbool_t_val, float32_t_ptr_val); + svldnt1(svbool_t_val, float64_t_ptr_val); + svldnt1(svbool_t_val, int8_t_ptr_val); + svldnt1(svbool_t_val, int16_t_ptr_val); + svldnt1(svbool_t_val, int32_t_ptr_val); + svldnt1(svbool_t_val, int64_t_ptr_val); + svldnt1(svbool_t_val, mfloat8_t_ptr_val); + svldnt1(svbool_t_val, uint8_t_ptr_val); + svldnt1(svbool_t_val, uint16_t_ptr_val); + svldnt1(svbool_t_val, uint32_t_ptr_val); + svldnt1(svbool_t_val, uint64_t_ptr_val); + svldnt1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svldnt1_f16(svbool_t_val, float16_t_ptr_val); + svldnt1_f32(svbool_t_val, float32_t_ptr_val); + svldnt1_f64(svbool_t_val, float64_t_ptr_val); + svldnt1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svldnt1_s8(svbool_t_val, int8_t_ptr_val); + svldnt1_s16(svbool_t_val, int16_t_ptr_val); + svldnt1_s32(svbool_t_val, int32_t_ptr_val); + svldnt1_s64(svbool_t_val, int64_t_ptr_val); + svldnt1_u8(svbool_t_val, uint8_t_ptr_val); + svldnt1_u16(svbool_t_val, uint16_t_ptr_val); + svldnt1_u32(svbool_t_val, uint32_t_ptr_val); + svldnt1_u64(svbool_t_val, uint64_t_ptr_val); + svldnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svlen(svbfloat16_t_val); + svlen(svfloat16_t_val); + svlen(svfloat32_t_val); + svlen(svfloat64_t_val); + svlen(svint8_t_val); + svlen(svint16_t_val); + svlen(svint32_t_val); + svlen(svint64_t_val); + svlen(svuint8_t_val); + svlen(svuint16_t_val); + svlen(svuint32_t_val); + svlen(svuint64_t_val); + svlen_bf16(svbfloat16_t_val); + svlen_f16(svfloat16_t_val); + svlen_f32(svfloat32_t_val); + svlen_f64(svfloat64_t_val); + svlen_s8(svint8_t_val); + svlen_s16(svint16_t_val); + svlen_s32(svint32_t_val); + svlen_s64(svint64_t_val); + svlen_u8(svuint8_t_val); + svlen_u16(svuint16_t_val); + svlen_u32(svuint32_t_val); + svlen_u64(svuint64_t_val); + svlsl_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmaxnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmv(svbool_t_val, svfloat16_t_val); + svmaxnmv(svbool_t_val, svfloat32_t_val); + svmaxnmv(svbool_t_val, svfloat64_t_val); + svmaxnmv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmv_f64(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svfloat16_t_val); + svmaxv(svbool_t_val, svfloat32_t_val); + svmaxv(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svint8_t_val); + svmaxv(svbool_t_val, svint16_t_val); + svmaxv(svbool_t_val, svint32_t_val); + svmaxv(svbool_t_val, svint64_t_val); + svmaxv(svbool_t_val, svuint8_t_val); + svmaxv(svbool_t_val, svuint16_t_val); + svmaxv(svbool_t_val, svuint32_t_val); + svmaxv(svbool_t_val, svuint64_t_val); + svmaxv_f16(svbool_t_val, svfloat16_t_val); + svmaxv_f32(svbool_t_val, svfloat32_t_val); + svmaxv_f64(svbool_t_val, svfloat64_t_val); + svmaxv_s8(svbool_t_val, svint8_t_val); + svmaxv_s16(svbool_t_val, svint16_t_val); + svmaxv_s32(svbool_t_val, svint32_t_val); + svmaxv_s64(svbool_t_val, svint64_t_val); + svmaxv_u8(svbool_t_val, svuint8_t_val); + svmaxv_u16(svbool_t_val, svuint16_t_val); + svmaxv_u32(svbool_t_val, svuint32_t_val); + svmaxv_u64(svbool_t_val, svuint64_t_val); + svmin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svminnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmv(svbool_t_val, svfloat16_t_val); + svminnmv(svbool_t_val, svfloat32_t_val); + svminnmv(svbool_t_val, svfloat64_t_val); + svminnmv_f16(svbool_t_val, svfloat16_t_val); + svminnmv_f32(svbool_t_val, svfloat32_t_val); + svminnmv_f64(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svfloat16_t_val); + svminv(svbool_t_val, svfloat32_t_val); + svminv(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svint8_t_val); + svminv(svbool_t_val, svint16_t_val); + svminv(svbool_t_val, svint32_t_val); + svminv(svbool_t_val, svint64_t_val); + svminv(svbool_t_val, svuint8_t_val); + svminv(svbool_t_val, svuint16_t_val); + svminv(svbool_t_val, svuint32_t_val); + svminv(svbool_t_val, svuint64_t_val); + svminv_f16(svbool_t_val, svfloat16_t_val); + svminv_f32(svbool_t_val, svfloat32_t_val); + svminv_f64(svbool_t_val, svfloat64_t_val); + svminv_s8(svbool_t_val, svint8_t_val); + svminv_s16(svbool_t_val, svint16_t_val); + svminv_s32(svbool_t_val, svint32_t_val); + svminv_s64(svbool_t_val, svint64_t_val); + svminv_u8(svbool_t_val, svuint8_t_val); + svminv_u16(svbool_t_val, svuint16_t_val); + svminv_u32(svbool_t_val, svuint32_t_val); + svminv_u64(svbool_t_val, svuint64_t_val); + svmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmov_b_z(svbool_t_val, svbool_t_val); + svmov_z(svbool_t_val, svbool_t_val); + svmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmul_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_lane(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane(svfloat64_t_val, svfloat64_t_val, 1); + svmul_lane_f16(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane_f32(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane_f64(svfloat64_t_val, svfloat64_t_val, 1); + svmul_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulx_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svnand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svneg_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_f16_x(svbool_t_val, svfloat16_t_val); + svneg_f16_z(svbool_t_val, svfloat16_t_val); + svneg_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_f32_x(svbool_t_val, svfloat32_t_val); + svneg_f32_z(svbool_t_val, svfloat32_t_val); + svneg_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_f64_x(svbool_t_val, svfloat64_t_val); + svneg_f64_z(svbool_t_val, svfloat64_t_val); + svneg_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_s8_x(svbool_t_val, svint8_t_val); + svneg_s8_z(svbool_t_val, svint8_t_val); + svneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_s16_x(svbool_t_val, svint16_t_val); + svneg_s16_z(svbool_t_val, svint16_t_val); + svneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_s32_x(svbool_t_val, svint32_t_val); + svneg_s32_z(svbool_t_val, svint32_t_val); + svneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s64_x(svbool_t_val, svint64_t_val); + svneg_s64_z(svbool_t_val, svint64_t_val); + svneg_x(svbool_t_val, svfloat16_t_val); + svneg_x(svbool_t_val, svfloat32_t_val); + svneg_x(svbool_t_val, svfloat64_t_val); + svneg_x(svbool_t_val, svint8_t_val); + svneg_x(svbool_t_val, svint16_t_val); + svneg_x(svbool_t_val, svint32_t_val); + svneg_x(svbool_t_val, svint64_t_val); + svneg_z(svbool_t_val, svfloat16_t_val); + svneg_z(svbool_t_val, svfloat32_t_val); + svneg_z(svbool_t_val, svfloat64_t_val); + svneg_z(svbool_t_val, svint8_t_val); + svneg_z(svbool_t_val, svint16_t_val); + svneg_z(svbool_t_val, svint32_t_val); + svneg_z(svbool_t_val, svint64_t_val); + svnmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnor_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnot_b_z(svbool_t_val, svbool_t_val); + svnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_s8_x(svbool_t_val, svint8_t_val); + svnot_s8_z(svbool_t_val, svint8_t_val); + svnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_s16_x(svbool_t_val, svint16_t_val); + svnot_s16_z(svbool_t_val, svint16_t_val); + svnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_s32_x(svbool_t_val, svint32_t_val); + svnot_s32_z(svbool_t_val, svint32_t_val); + svnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_s64_x(svbool_t_val, svint64_t_val); + svnot_s64_z(svbool_t_val, svint64_t_val); + svnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_u8_x(svbool_t_val, svuint8_t_val); + svnot_u8_z(svbool_t_val, svuint8_t_val); + svnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_u16_x(svbool_t_val, svuint16_t_val); + svnot_u16_z(svbool_t_val, svuint16_t_val); + svnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_u32_x(svbool_t_val, svuint32_t_val); + svnot_u32_z(svbool_t_val, svuint32_t_val); + svnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_u64_x(svbool_t_val, svuint64_t_val); + svnot_u64_z(svbool_t_val, svuint64_t_val); + svnot_x(svbool_t_val, svint8_t_val); + svnot_x(svbool_t_val, svint16_t_val); + svnot_x(svbool_t_val, svint32_t_val); + svnot_x(svbool_t_val, svint64_t_val); + svnot_x(svbool_t_val, svuint8_t_val); + svnot_x(svbool_t_val, svuint16_t_val); + svnot_x(svbool_t_val, svuint32_t_val); + svnot_x(svbool_t_val, svuint64_t_val); + svnot_z(svbool_t_val, svbool_t_val); + svnot_z(svbool_t_val, svint8_t_val); + svnot_z(svbool_t_val, svint16_t_val); + svnot_z(svbool_t_val, svint32_t_val); + svnot_z(svbool_t_val, svint64_t_val); + svnot_z(svbool_t_val, svuint8_t_val); + svnot_z(svbool_t_val, svuint16_t_val); + svnot_z(svbool_t_val, svuint32_t_val); + svnot_z(svbool_t_val, svuint64_t_val); + svorn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorv(svbool_t_val, svint8_t_val); + svorv(svbool_t_val, svint16_t_val); + svorv(svbool_t_val, svint32_t_val); + svorv(svbool_t_val, svint64_t_val); + svorv(svbool_t_val, svuint8_t_val); + svorv(svbool_t_val, svuint16_t_val); + svorv(svbool_t_val, svuint32_t_val); + svorv(svbool_t_val, svuint64_t_val); + svorv_s8(svbool_t_val, svint8_t_val); + svorv_s16(svbool_t_val, svint16_t_val); + svorv_s32(svbool_t_val, svint32_t_val); + svorv_s64(svbool_t_val, svint64_t_val); + svorv_u8(svbool_t_val, svuint8_t_val); + svorv_u16(svbool_t_val, svuint16_t_val); + svorv_u32(svbool_t_val, svuint32_t_val); + svorv_u64(svbool_t_val, svuint64_t_val); + svpfalse(); + svpfalse_b(); + svpfirst(svbool_t_val, svbool_t_val); + svpfirst_b(svbool_t_val, svbool_t_val); + svpnext_b8(svbool_t_val, svbool_t_val); + svpnext_b16(svbool_t_val, svbool_t_val); + svpnext_b32(svbool_t_val, svbool_t_val); + svpnext_b64(svbool_t_val, svbool_t_val); + svprfb(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfb_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfd(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfd_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfh(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfh_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfw(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfw_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svptest_any(svbool_t_val, svbool_t_val); + svptest_first(svbool_t_val, svbool_t_val); + svptest_last(svbool_t_val, svbool_t_val); + svptrue_b8(); + svptrue_b16(); + svptrue_b32(); + svptrue_b64(); + svptrue_pat_b8(SV_MUL3); + svptrue_pat_b16(SV_MUL3); + svptrue_pat_b32(SV_MUL3); + svptrue_pat_b64(SV_MUL3); + svqadd(svint8_t_val, int8_t_val); + svqadd(svint8_t_val, svint8_t_val); + svqadd(svint16_t_val, int16_t_val); + svqadd(svint16_t_val, svint16_t_val); + svqadd(svint32_t_val, int32_t_val); + svqadd(svint32_t_val, svint32_t_val); + svqadd(svint64_t_val, int64_t_val); + svqadd(svint64_t_val, svint64_t_val); + svqadd(svuint8_t_val, svuint8_t_val); + svqadd(svuint8_t_val, uint8_t_val); + svqadd(svuint16_t_val, svuint16_t_val); + svqadd(svuint16_t_val, uint16_t_val); + svqadd(svuint32_t_val, svuint32_t_val); + svqadd(svuint32_t_val, uint32_t_val); + svqadd(svuint64_t_val, svuint64_t_val); + svqadd(svuint64_t_val, uint64_t_val); + svqadd_n_s8(svint8_t_val, int8_t_val); + svqadd_n_s16(svint16_t_val, int16_t_val); + svqadd_n_s32(svint32_t_val, int32_t_val); + svqadd_n_s64(svint64_t_val, int64_t_val); + svqadd_n_u8(svuint8_t_val, uint8_t_val); + svqadd_n_u16(svuint16_t_val, uint16_t_val); + svqadd_n_u32(svuint32_t_val, uint32_t_val); + svqadd_n_u64(svuint64_t_val, uint64_t_val); + svqadd_s8(svint8_t_val, svint8_t_val); + svqadd_s16(svint16_t_val, svint16_t_val); + svqadd_s32(svint32_t_val, svint32_t_val); + svqadd_s64(svint64_t_val, svint64_t_val); + svqadd_u8(svuint8_t_val, svuint8_t_val); + svqadd_u16(svuint16_t_val, svuint16_t_val); + svqadd_u32(svuint32_t_val, svuint32_t_val); + svqadd_u64(svuint64_t_val, svuint64_t_val); + svqdecb(int32_t_val, 2); + svqdecb(int64_t_val, 2); + svqdecb(uint32_t_val, 2); + svqdecb(uint64_t_val, 2); + svqdecb_n_s32(int32_t_val, 2); + svqdecb_n_s64(int64_t_val, 2); + svqdecb_n_u32(uint32_t_val, 2); + svqdecb_n_u64(uint64_t_val, 2); + svqdecb_pat(int32_t_val, SV_MUL3, 2); + svqdecb_pat(int64_t_val, SV_MUL3, 2); + svqdecb_pat(uint32_t_val, SV_MUL3, 2); + svqdecb_pat(uint64_t_val, SV_MUL3, 2); + svqdecb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd(int32_t_val, 2); + svqdecd(int64_t_val, 2); + svqdecd(svint64_t_val, 2); + svqdecd(svuint64_t_val, 2); + svqdecd(uint32_t_val, 2); + svqdecd(uint64_t_val, 2); + svqdecd_n_s32(int32_t_val, 2); + svqdecd_n_s64(int64_t_val, 2); + svqdecd_n_u32(uint32_t_val, 2); + svqdecd_n_u64(uint64_t_val, 2); + svqdecd_pat(int32_t_val, SV_MUL3, 2); + svqdecd_pat(int64_t_val, SV_MUL3, 2); + svqdecd_pat(svint64_t_val, SV_MUL3, 2); + svqdecd_pat(svuint64_t_val, SV_MUL3, 2); + svqdecd_pat(uint32_t_val, SV_MUL3, 2); + svqdecd_pat(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqdecd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqdecd_s64(svint64_t_val, 2); + svqdecd_u64(svuint64_t_val, 2); + svqdech(int32_t_val, 2); + svqdech(int64_t_val, 2); + svqdech(svint16_t_val, 2); + svqdech(svuint16_t_val, 2); + svqdech(uint32_t_val, 2); + svqdech(uint64_t_val, 2); + svqdech_n_s32(int32_t_val, 2); + svqdech_n_s64(int64_t_val, 2); + svqdech_n_u32(uint32_t_val, 2); + svqdech_n_u64(uint64_t_val, 2); + svqdech_pat(int32_t_val, SV_MUL3, 2); + svqdech_pat(int64_t_val, SV_MUL3, 2); + svqdech_pat(svint16_t_val, SV_MUL3, 2); + svqdech_pat(svuint16_t_val, SV_MUL3, 2); + svqdech_pat(uint32_t_val, SV_MUL3, 2); + svqdech_pat(uint64_t_val, SV_MUL3, 2); + svqdech_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdech_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdech_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdech_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdech_pat_s16(svint16_t_val, SV_MUL3, 2); + svqdech_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqdech_s16(svint16_t_val, 2); + svqdech_u16(svuint16_t_val, 2); + svqdecp(svint16_t_val, svbool_t_val); + svqdecp(svint32_t_val, svbool_t_val); + svqdecp(svint64_t_val, svbool_t_val); + svqdecp(svuint16_t_val, svbool_t_val); + svqdecp(svuint32_t_val, svbool_t_val); + svqdecp(svuint64_t_val, svbool_t_val); + svqdecp_b8(int32_t_val, svbool_t_val); + svqdecp_b8(int64_t_val, svbool_t_val); + svqdecp_b8(uint32_t_val, svbool_t_val); + svqdecp_b8(uint64_t_val, svbool_t_val); + svqdecp_b16(int32_t_val, svbool_t_val); + svqdecp_b16(int64_t_val, svbool_t_val); + svqdecp_b16(uint32_t_val, svbool_t_val); + svqdecp_b16(uint64_t_val, svbool_t_val); + svqdecp_b32(int32_t_val, svbool_t_val); + svqdecp_b32(int64_t_val, svbool_t_val); + svqdecp_b32(uint32_t_val, svbool_t_val); + svqdecp_b32(uint64_t_val, svbool_t_val); + svqdecp_b64(int32_t_val, svbool_t_val); + svqdecp_b64(int64_t_val, svbool_t_val); + svqdecp_b64(uint32_t_val, svbool_t_val); + svqdecp_b64(uint64_t_val, svbool_t_val); + svqdecp_n_s32_b8(int32_t_val, svbool_t_val); + svqdecp_n_s32_b16(int32_t_val, svbool_t_val); + svqdecp_n_s32_b32(int32_t_val, svbool_t_val); + svqdecp_n_s32_b64(int32_t_val, svbool_t_val); + svqdecp_n_s64_b8(int64_t_val, svbool_t_val); + svqdecp_n_s64_b16(int64_t_val, svbool_t_val); + svqdecp_n_s64_b32(int64_t_val, svbool_t_val); + svqdecp_n_s64_b64(int64_t_val, svbool_t_val); + svqdecp_n_u32_b8(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b16(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b32(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b64(uint32_t_val, svbool_t_val); + svqdecp_n_u64_b8(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b16(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b32(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b64(uint64_t_val, svbool_t_val); + svqdecp_s16(svint16_t_val, svbool_t_val); + svqdecp_s32(svint32_t_val, svbool_t_val); + svqdecp_s64(svint64_t_val, svbool_t_val); + svqdecp_u16(svuint16_t_val, svbool_t_val); + svqdecp_u32(svuint32_t_val, svbool_t_val); + svqdecp_u64(svuint64_t_val, svbool_t_val); + svqdecw(int32_t_val, 2); + svqdecw(int64_t_val, 2); + svqdecw(svint32_t_val, 2); + svqdecw(svuint32_t_val, 2); + svqdecw(uint32_t_val, 2); + svqdecw(uint64_t_val, 2); + svqdecw_n_s32(int32_t_val, 2); + svqdecw_n_s64(int64_t_val, 2); + svqdecw_n_u32(uint32_t_val, 2); + svqdecw_n_u64(uint64_t_val, 2); + svqdecw_pat(int32_t_val, SV_MUL3, 2); + svqdecw_pat(int64_t_val, SV_MUL3, 2); + svqdecw_pat(svint32_t_val, SV_MUL3, 2); + svqdecw_pat(svuint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqdecw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqdecw_s32(svint32_t_val, 2); + svqdecw_u32(svuint32_t_val, 2); + svqincb(int32_t_val, 2); + svqincb(int64_t_val, 2); + svqincb(uint32_t_val, 2); + svqincb(uint64_t_val, 2); + svqincb_n_s32(int32_t_val, 2); + svqincb_n_s64(int64_t_val, 2); + svqincb_n_u32(uint32_t_val, 2); + svqincb_n_u64(uint64_t_val, 2); + svqincb_pat(int32_t_val, SV_MUL3, 2); + svqincb_pat(int64_t_val, SV_MUL3, 2); + svqincb_pat(uint32_t_val, SV_MUL3, 2); + svqincb_pat(uint64_t_val, SV_MUL3, 2); + svqincb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd(int32_t_val, 2); + svqincd(int64_t_val, 2); + svqincd(svint64_t_val, 2); + svqincd(svuint64_t_val, 2); + svqincd(uint32_t_val, 2); + svqincd(uint64_t_val, 2); + svqincd_n_s32(int32_t_val, 2); + svqincd_n_s64(int64_t_val, 2); + svqincd_n_u32(uint32_t_val, 2); + svqincd_n_u64(uint64_t_val, 2); + svqincd_pat(int32_t_val, SV_MUL3, 2); + svqincd_pat(int64_t_val, SV_MUL3, 2); + svqincd_pat(svint64_t_val, SV_MUL3, 2); + svqincd_pat(svuint64_t_val, SV_MUL3, 2); + svqincd_pat(uint32_t_val, SV_MUL3, 2); + svqincd_pat(uint64_t_val, SV_MUL3, 2); + svqincd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqincd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqincd_s64(svint64_t_val, 2); + svqincd_u64(svuint64_t_val, 2); + svqinch(int32_t_val, 2); + svqinch(int64_t_val, 2); + svqinch(svint16_t_val, 2); + svqinch(svuint16_t_val, 2); + svqinch(uint32_t_val, 2); + svqinch(uint64_t_val, 2); + svqinch_n_s32(int32_t_val, 2); + svqinch_n_s64(int64_t_val, 2); + svqinch_n_u32(uint32_t_val, 2); + svqinch_n_u64(uint64_t_val, 2); + svqinch_pat(int32_t_val, SV_MUL3, 2); + svqinch_pat(int64_t_val, SV_MUL3, 2); + svqinch_pat(svint16_t_val, SV_MUL3, 2); + svqinch_pat(svuint16_t_val, SV_MUL3, 2); + svqinch_pat(uint32_t_val, SV_MUL3, 2); + svqinch_pat(uint64_t_val, SV_MUL3, 2); + svqinch_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqinch_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqinch_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqinch_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqinch_pat_s16(svint16_t_val, SV_MUL3, 2); + svqinch_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqinch_s16(svint16_t_val, 2); + svqinch_u16(svuint16_t_val, 2); + svqincp(svint16_t_val, svbool_t_val); + svqincp(svint32_t_val, svbool_t_val); + svqincp(svint64_t_val, svbool_t_val); + svqincp(svuint16_t_val, svbool_t_val); + svqincp(svuint32_t_val, svbool_t_val); + svqincp(svuint64_t_val, svbool_t_val); + svqincp_b8(int32_t_val, svbool_t_val); + svqincp_b8(int64_t_val, svbool_t_val); + svqincp_b8(uint32_t_val, svbool_t_val); + svqincp_b8(uint64_t_val, svbool_t_val); + svqincp_b16(int32_t_val, svbool_t_val); + svqincp_b16(int64_t_val, svbool_t_val); + svqincp_b16(uint32_t_val, svbool_t_val); + svqincp_b16(uint64_t_val, svbool_t_val); + svqincp_b32(int32_t_val, svbool_t_val); + svqincp_b32(int64_t_val, svbool_t_val); + svqincp_b32(uint32_t_val, svbool_t_val); + svqincp_b32(uint64_t_val, svbool_t_val); + svqincp_b64(int32_t_val, svbool_t_val); + svqincp_b64(int64_t_val, svbool_t_val); + svqincp_b64(uint32_t_val, svbool_t_val); + svqincp_b64(uint64_t_val, svbool_t_val); + svqincp_n_s32_b8(int32_t_val, svbool_t_val); + svqincp_n_s32_b16(int32_t_val, svbool_t_val); + svqincp_n_s32_b32(int32_t_val, svbool_t_val); + svqincp_n_s32_b64(int32_t_val, svbool_t_val); + svqincp_n_s64_b8(int64_t_val, svbool_t_val); + svqincp_n_s64_b16(int64_t_val, svbool_t_val); + svqincp_n_s64_b32(int64_t_val, svbool_t_val); + svqincp_n_s64_b64(int64_t_val, svbool_t_val); + svqincp_n_u32_b8(uint32_t_val, svbool_t_val); + svqincp_n_u32_b16(uint32_t_val, svbool_t_val); + svqincp_n_u32_b32(uint32_t_val, svbool_t_val); + svqincp_n_u32_b64(uint32_t_val, svbool_t_val); + svqincp_n_u64_b8(uint64_t_val, svbool_t_val); + svqincp_n_u64_b16(uint64_t_val, svbool_t_val); + svqincp_n_u64_b32(uint64_t_val, svbool_t_val); + svqincp_n_u64_b64(uint64_t_val, svbool_t_val); + svqincp_s16(svint16_t_val, svbool_t_val); + svqincp_s32(svint32_t_val, svbool_t_val); + svqincp_s64(svint64_t_val, svbool_t_val); + svqincp_u16(svuint16_t_val, svbool_t_val); + svqincp_u32(svuint32_t_val, svbool_t_val); + svqincp_u64(svuint64_t_val, svbool_t_val); + svqincw(int32_t_val, 2); + svqincw(int64_t_val, 2); + svqincw(svint32_t_val, 2); + svqincw(svuint32_t_val, 2); + svqincw(uint32_t_val, 2); + svqincw(uint64_t_val, 2); + svqincw_n_s32(int32_t_val, 2); + svqincw_n_s64(int64_t_val, 2); + svqincw_n_u32(uint32_t_val, 2); + svqincw_n_u64(uint64_t_val, 2); + svqincw_pat(int32_t_val, SV_MUL3, 2); + svqincw_pat(int64_t_val, SV_MUL3, 2); + svqincw_pat(svint32_t_val, SV_MUL3, 2); + svqincw_pat(svuint32_t_val, SV_MUL3, 2); + svqincw_pat(uint32_t_val, SV_MUL3, 2); + svqincw_pat(uint64_t_val, SV_MUL3, 2); + svqincw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqincw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqincw_s32(svint32_t_val, 2); + svqincw_u32(svuint32_t_val, 2); + svqsub(svint8_t_val, int8_t_val); + svqsub(svint8_t_val, svint8_t_val); + svqsub(svint16_t_val, int16_t_val); + svqsub(svint16_t_val, svint16_t_val); + svqsub(svint32_t_val, int32_t_val); + svqsub(svint32_t_val, svint32_t_val); + svqsub(svint64_t_val, int64_t_val); + svqsub(svint64_t_val, svint64_t_val); + svqsub(svuint8_t_val, svuint8_t_val); + svqsub(svuint8_t_val, uint8_t_val); + svqsub(svuint16_t_val, svuint16_t_val); + svqsub(svuint16_t_val, uint16_t_val); + svqsub(svuint32_t_val, svuint32_t_val); + svqsub(svuint32_t_val, uint32_t_val); + svqsub(svuint64_t_val, svuint64_t_val); + svqsub(svuint64_t_val, uint64_t_val); + svqsub_n_s8(svint8_t_val, int8_t_val); + svqsub_n_s16(svint16_t_val, int16_t_val); + svqsub_n_s32(svint32_t_val, int32_t_val); + svqsub_n_s64(svint64_t_val, int64_t_val); + svqsub_n_u8(svuint8_t_val, uint8_t_val); + svqsub_n_u16(svuint16_t_val, uint16_t_val); + svqsub_n_u32(svuint32_t_val, uint32_t_val); + svqsub_n_u64(svuint64_t_val, uint64_t_val); + svqsub_s8(svint8_t_val, svint8_t_val); + svqsub_s16(svint16_t_val, svint16_t_val); + svqsub_s32(svint32_t_val, svint32_t_val); + svqsub_s64(svint64_t_val, svint64_t_val); + svqsub_u8(svuint8_t_val, svuint8_t_val); + svqsub_u16(svuint16_t_val, svuint16_t_val); + svqsub_u32(svuint32_t_val, svuint32_t_val); + svqsub_u64(svuint64_t_val, svuint64_t_val); + svrbit_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_s8_x(svbool_t_val, svint8_t_val); + svrbit_s8_z(svbool_t_val, svint8_t_val); + svrbit_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_s16_x(svbool_t_val, svint16_t_val); + svrbit_s16_z(svbool_t_val, svint16_t_val); + svrbit_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_s32_x(svbool_t_val, svint32_t_val); + svrbit_s32_z(svbool_t_val, svint32_t_val); + svrbit_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_s64_x(svbool_t_val, svint64_t_val); + svrbit_s64_z(svbool_t_val, svint64_t_val); + svrbit_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_u8_x(svbool_t_val, svuint8_t_val); + svrbit_u8_z(svbool_t_val, svuint8_t_val); + svrbit_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_u16_x(svbool_t_val, svuint16_t_val); + svrbit_u16_z(svbool_t_val, svuint16_t_val); + svrbit_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_u32_x(svbool_t_val, svuint32_t_val); + svrbit_u32_z(svbool_t_val, svuint32_t_val); + svrbit_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_u64_x(svbool_t_val, svuint64_t_val); + svrbit_u64_z(svbool_t_val, svuint64_t_val); + svrbit_x(svbool_t_val, svint8_t_val); + svrbit_x(svbool_t_val, svint16_t_val); + svrbit_x(svbool_t_val, svint32_t_val); + svrbit_x(svbool_t_val, svint64_t_val); + svrbit_x(svbool_t_val, svuint8_t_val); + svrbit_x(svbool_t_val, svuint16_t_val); + svrbit_x(svbool_t_val, svuint32_t_val); + svrbit_x(svbool_t_val, svuint64_t_val); + svrbit_z(svbool_t_val, svint8_t_val); + svrbit_z(svbool_t_val, svint16_t_val); + svrbit_z(svbool_t_val, svint32_t_val); + svrbit_z(svbool_t_val, svint64_t_val); + svrbit_z(svbool_t_val, svuint8_t_val); + svrbit_z(svbool_t_val, svuint16_t_val); + svrbit_z(svbool_t_val, svuint32_t_val); + svrbit_z(svbool_t_val, svuint64_t_val); + svrecpe(svfloat16_t_val); + svrecpe(svfloat32_t_val); + svrecpe(svfloat64_t_val); + svrecpe_f16(svfloat16_t_val); + svrecpe_f32(svfloat32_t_val); + svrecpe_f64(svfloat64_t_val); + svrecps(svfloat16_t_val, svfloat16_t_val); + svrecps(svfloat32_t_val, svfloat32_t_val); + svrecps(svfloat64_t_val, svfloat64_t_val); + svrecps_f16(svfloat16_t_val, svfloat16_t_val); + svrecps_f32(svfloat32_t_val, svfloat32_t_val); + svrecps_f64(svfloat64_t_val, svfloat64_t_val); + svrecpx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_f16_x(svbool_t_val, svfloat16_t_val); + svrecpx_f16_z(svbool_t_val, svfloat16_t_val); + svrecpx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_f32_x(svbool_t_val, svfloat32_t_val); + svrecpx_f32_z(svbool_t_val, svfloat32_t_val); + svrecpx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_f64_x(svbool_t_val, svfloat64_t_val); + svrecpx_f64_z(svbool_t_val, svfloat64_t_val); + svrecpx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_x(svbool_t_val, svfloat16_t_val); + svrecpx_x(svbool_t_val, svfloat32_t_val); + svrecpx_x(svbool_t_val, svfloat64_t_val); + svrecpx_z(svbool_t_val, svfloat16_t_val); + svrecpx_z(svbool_t_val, svfloat32_t_val); + svrecpx_z(svbool_t_val, svfloat64_t_val); + svrev(svbfloat16_t_val); + svrev(svfloat16_t_val); + svrev(svfloat32_t_val); + svrev(svfloat64_t_val); + svrev(svint8_t_val); + svrev(svint16_t_val); + svrev(svint32_t_val); + svrev(svint64_t_val); + svrev(svuint8_t_val); + svrev(svuint16_t_val); + svrev(svuint32_t_val); + svrev(svuint64_t_val); + svrev_b8(svbool_t_val); + svrev_b16(svbool_t_val); + svrev_b32(svbool_t_val); + svrev_b64(svbool_t_val); + svrev_bf16(svbfloat16_t_val); + svrev_f16(svfloat16_t_val); + svrev_f32(svfloat32_t_val); + svrev_f64(svfloat64_t_val); + svrev_s8(svint8_t_val); + svrev_s16(svint16_t_val); + svrev_s32(svint32_t_val); + svrev_s64(svint64_t_val); + svrev_u8(svuint8_t_val); + svrev_u16(svuint16_t_val); + svrev_u32(svuint32_t_val); + svrev_u64(svuint64_t_val); + svrevb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_s16_x(svbool_t_val, svint16_t_val); + svrevb_s16_z(svbool_t_val, svint16_t_val); + svrevb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_s32_x(svbool_t_val, svint32_t_val); + svrevb_s32_z(svbool_t_val, svint32_t_val); + svrevb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_s64_x(svbool_t_val, svint64_t_val); + svrevb_s64_z(svbool_t_val, svint64_t_val); + svrevb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_u16_x(svbool_t_val, svuint16_t_val); + svrevb_u16_z(svbool_t_val, svuint16_t_val); + svrevb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_u32_x(svbool_t_val, svuint32_t_val); + svrevb_u32_z(svbool_t_val, svuint32_t_val); + svrevb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_u64_x(svbool_t_val, svuint64_t_val); + svrevb_u64_z(svbool_t_val, svuint64_t_val); + svrevb_x(svbool_t_val, svint16_t_val); + svrevb_x(svbool_t_val, svint32_t_val); + svrevb_x(svbool_t_val, svint64_t_val); + svrevb_x(svbool_t_val, svuint16_t_val); + svrevb_x(svbool_t_val, svuint32_t_val); + svrevb_x(svbool_t_val, svuint64_t_val); + svrevb_z(svbool_t_val, svint16_t_val); + svrevb_z(svbool_t_val, svint32_t_val); + svrevb_z(svbool_t_val, svint64_t_val); + svrevb_z(svbool_t_val, svuint16_t_val); + svrevb_z(svbool_t_val, svuint32_t_val); + svrevb_z(svbool_t_val, svuint64_t_val); + svrevh_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_s32_x(svbool_t_val, svint32_t_val); + svrevh_s32_z(svbool_t_val, svint32_t_val); + svrevh_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_s64_x(svbool_t_val, svint64_t_val); + svrevh_s64_z(svbool_t_val, svint64_t_val); + svrevh_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_u32_x(svbool_t_val, svuint32_t_val); + svrevh_u32_z(svbool_t_val, svuint32_t_val); + svrevh_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_u64_x(svbool_t_val, svuint64_t_val); + svrevh_u64_z(svbool_t_val, svuint64_t_val); + svrevh_x(svbool_t_val, svint32_t_val); + svrevh_x(svbool_t_val, svint64_t_val); + svrevh_x(svbool_t_val, svuint32_t_val); + svrevh_x(svbool_t_val, svuint64_t_val); + svrevh_z(svbool_t_val, svint32_t_val); + svrevh_z(svbool_t_val, svint64_t_val); + svrevh_z(svbool_t_val, svuint32_t_val); + svrevh_z(svbool_t_val, svuint64_t_val); + svrevw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_s64_x(svbool_t_val, svint64_t_val); + svrevw_s64_z(svbool_t_val, svint64_t_val); + svrevw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_u64_x(svbool_t_val, svuint64_t_val); + svrevw_u64_z(svbool_t_val, svuint64_t_val); + svrevw_x(svbool_t_val, svint64_t_val); + svrevw_x(svbool_t_val, svuint64_t_val); + svrevw_z(svbool_t_val, svint64_t_val); + svrevw_z(svbool_t_val, svuint64_t_val); + svrinta_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_f16_x(svbool_t_val, svfloat16_t_val); + svrinta_f16_z(svbool_t_val, svfloat16_t_val); + svrinta_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_f32_x(svbool_t_val, svfloat32_t_val); + svrinta_f32_z(svbool_t_val, svfloat32_t_val); + svrinta_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_f64_x(svbool_t_val, svfloat64_t_val); + svrinta_f64_z(svbool_t_val, svfloat64_t_val); + svrinta_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_x(svbool_t_val, svfloat16_t_val); + svrinta_x(svbool_t_val, svfloat32_t_val); + svrinta_x(svbool_t_val, svfloat64_t_val); + svrinta_z(svbool_t_val, svfloat16_t_val); + svrinta_z(svbool_t_val, svfloat32_t_val); + svrinta_z(svbool_t_val, svfloat64_t_val); + svrinti_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_f16_x(svbool_t_val, svfloat16_t_val); + svrinti_f16_z(svbool_t_val, svfloat16_t_val); + svrinti_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_f32_x(svbool_t_val, svfloat32_t_val); + svrinti_f32_z(svbool_t_val, svfloat32_t_val); + svrinti_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_f64_x(svbool_t_val, svfloat64_t_val); + svrinti_f64_z(svbool_t_val, svfloat64_t_val); + svrinti_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_x(svbool_t_val, svfloat16_t_val); + svrinti_x(svbool_t_val, svfloat32_t_val); + svrinti_x(svbool_t_val, svfloat64_t_val); + svrinti_z(svbool_t_val, svfloat16_t_val); + svrinti_z(svbool_t_val, svfloat32_t_val); + svrinti_z(svbool_t_val, svfloat64_t_val); + svrintm_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_f16_x(svbool_t_val, svfloat16_t_val); + svrintm_f16_z(svbool_t_val, svfloat16_t_val); + svrintm_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_f32_x(svbool_t_val, svfloat32_t_val); + svrintm_f32_z(svbool_t_val, svfloat32_t_val); + svrintm_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_f64_x(svbool_t_val, svfloat64_t_val); + svrintm_f64_z(svbool_t_val, svfloat64_t_val); + svrintm_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_x(svbool_t_val, svfloat16_t_val); + svrintm_x(svbool_t_val, svfloat32_t_val); + svrintm_x(svbool_t_val, svfloat64_t_val); + svrintm_z(svbool_t_val, svfloat16_t_val); + svrintm_z(svbool_t_val, svfloat32_t_val); + svrintm_z(svbool_t_val, svfloat64_t_val); + svrintn_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_f16_x(svbool_t_val, svfloat16_t_val); + svrintn_f16_z(svbool_t_val, svfloat16_t_val); + svrintn_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_f32_x(svbool_t_val, svfloat32_t_val); + svrintn_f32_z(svbool_t_val, svfloat32_t_val); + svrintn_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_f64_x(svbool_t_val, svfloat64_t_val); + svrintn_f64_z(svbool_t_val, svfloat64_t_val); + svrintn_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_x(svbool_t_val, svfloat16_t_val); + svrintn_x(svbool_t_val, svfloat32_t_val); + svrintn_x(svbool_t_val, svfloat64_t_val); + svrintn_z(svbool_t_val, svfloat16_t_val); + svrintn_z(svbool_t_val, svfloat32_t_val); + svrintn_z(svbool_t_val, svfloat64_t_val); + svrintp_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_f16_x(svbool_t_val, svfloat16_t_val); + svrintp_f16_z(svbool_t_val, svfloat16_t_val); + svrintp_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_f32_x(svbool_t_val, svfloat32_t_val); + svrintp_f32_z(svbool_t_val, svfloat32_t_val); + svrintp_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_f64_x(svbool_t_val, svfloat64_t_val); + svrintp_f64_z(svbool_t_val, svfloat64_t_val); + svrintp_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_x(svbool_t_val, svfloat16_t_val); + svrintp_x(svbool_t_val, svfloat32_t_val); + svrintp_x(svbool_t_val, svfloat64_t_val); + svrintp_z(svbool_t_val, svfloat16_t_val); + svrintp_z(svbool_t_val, svfloat32_t_val); + svrintp_z(svbool_t_val, svfloat64_t_val); + svrintx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_f16_x(svbool_t_val, svfloat16_t_val); + svrintx_f16_z(svbool_t_val, svfloat16_t_val); + svrintx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_f32_x(svbool_t_val, svfloat32_t_val); + svrintx_f32_z(svbool_t_val, svfloat32_t_val); + svrintx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_f64_x(svbool_t_val, svfloat64_t_val); + svrintx_f64_z(svbool_t_val, svfloat64_t_val); + svrintx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_x(svbool_t_val, svfloat16_t_val); + svrintx_x(svbool_t_val, svfloat32_t_val); + svrintx_x(svbool_t_val, svfloat64_t_val); + svrintx_z(svbool_t_val, svfloat16_t_val); + svrintx_z(svbool_t_val, svfloat32_t_val); + svrintx_z(svbool_t_val, svfloat64_t_val); + svrintz_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_f16_x(svbool_t_val, svfloat16_t_val); + svrintz_f16_z(svbool_t_val, svfloat16_t_val); + svrintz_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_f32_x(svbool_t_val, svfloat32_t_val); + svrintz_f32_z(svbool_t_val, svfloat32_t_val); + svrintz_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_f64_x(svbool_t_val, svfloat64_t_val); + svrintz_f64_z(svbool_t_val, svfloat64_t_val); + svrintz_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_x(svbool_t_val, svfloat16_t_val); + svrintz_x(svbool_t_val, svfloat32_t_val); + svrintz_x(svbool_t_val, svfloat64_t_val); + svrintz_z(svbool_t_val, svfloat16_t_val); + svrintz_z(svbool_t_val, svfloat32_t_val); + svrintz_z(svbool_t_val, svfloat64_t_val); + svrsqrte(svfloat16_t_val); + svrsqrte(svfloat32_t_val); + svrsqrte(svfloat64_t_val); + svrsqrte_f16(svfloat16_t_val); + svrsqrte_f32(svfloat32_t_val); + svrsqrte_f64(svfloat64_t_val); + svrsqrts(svfloat16_t_val, svfloat16_t_val); + svrsqrts(svfloat32_t_val, svfloat32_t_val); + svrsqrts(svfloat64_t_val, svfloat64_t_val); + svrsqrts_f16(svfloat16_t_val, svfloat16_t_val); + svrsqrts_f32(svfloat32_t_val, svfloat32_t_val); + svrsqrts_f64(svfloat64_t_val, svfloat64_t_val); + svscale_f16_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f32_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f64_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_n_f16_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f32_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f64_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svsel(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel(svbool_t_val, svbool_t_val, svbool_t_val); + svsel(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel(svbool_t_val, svint8_t_val, svint8_t_val); + svsel(svbool_t_val, svint16_t_val, svint16_t_val); + svsel(svbool_t_val, svint32_t_val, svint32_t_val); + svsel(svbool_t_val, svint64_t_val, svint64_t_val); + svsel(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsel_b(svbool_t_val, svbool_t_val, svbool_t_val); + svsel_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsel_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsel_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsel_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsel_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svset2(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2(svint8x2_t_val, 1, svint8_t_val); + svset2(svint16x2_t_val, 1, svint16_t_val); + svset2(svint32x2_t_val, 1, svint32_t_val); + svset2(svint64x2_t_val, 1, svint64_t_val); + svset2(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2(svuint8x2_t_val, 1, svuint8_t_val); + svset2(svuint16x2_t_val, 1, svuint16_t_val); + svset2(svuint32x2_t_val, 1, svuint32_t_val); + svset2(svuint64x2_t_val, 1, svuint64_t_val); + svset2_bf16(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2_f16(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2_f32(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2_f64(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2_mf8(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2_s8(svint8x2_t_val, 1, svint8_t_val); + svset2_s16(svint16x2_t_val, 1, svint16_t_val); + svset2_s32(svint32x2_t_val, 1, svint32_t_val); + svset2_s64(svint64x2_t_val, 1, svint64_t_val); + svset2_u8(svuint8x2_t_val, 1, svuint8_t_val); + svset2_u16(svuint16x2_t_val, 1, svuint16_t_val); + svset2_u32(svuint32x2_t_val, 1, svuint32_t_val); + svset2_u64(svuint64x2_t_val, 1, svuint64_t_val); + svset3(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3(svint8x3_t_val, 2, svint8_t_val); + svset3(svint16x3_t_val, 2, svint16_t_val); + svset3(svint32x3_t_val, 2, svint32_t_val); + svset3(svint64x3_t_val, 2, svint64_t_val); + svset3(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3(svuint8x3_t_val, 2, svuint8_t_val); + svset3(svuint16x3_t_val, 2, svuint16_t_val); + svset3(svuint32x3_t_val, 2, svuint32_t_val); + svset3(svuint64x3_t_val, 2, svuint64_t_val); + svset3_bf16(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3_f16(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3_f32(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3_f64(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3_mf8(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3_s8(svint8x3_t_val, 2, svint8_t_val); + svset3_s16(svint16x3_t_val, 2, svint16_t_val); + svset3_s32(svint32x3_t_val, 2, svint32_t_val); + svset3_s64(svint64x3_t_val, 2, svint64_t_val); + svset3_u8(svuint8x3_t_val, 2, svuint8_t_val); + svset3_u16(svuint16x3_t_val, 2, svuint16_t_val); + svset3_u32(svuint32x3_t_val, 2, svuint32_t_val); + svset3_u64(svuint64x3_t_val, 2, svuint64_t_val); + svset4(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4(svint8x4_t_val, 2, svint8_t_val); + svset4(svint16x4_t_val, 2, svint16_t_val); + svset4(svint32x4_t_val, 2, svint32_t_val); + svset4(svint64x4_t_val, 2, svint64_t_val); + svset4(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4(svuint8x4_t_val, 2, svuint8_t_val); + svset4(svuint16x4_t_val, 2, svuint16_t_val); + svset4(svuint32x4_t_val, 2, svuint32_t_val); + svset4(svuint64x4_t_val, 2, svuint64_t_val); + svset4_bf16(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4_f16(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4_f32(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4_f64(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4_mf8(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4_s8(svint8x4_t_val, 2, svint8_t_val); + svset4_s16(svint16x4_t_val, 2, svint16_t_val); + svset4_s32(svint32x4_t_val, 2, svint32_t_val); + svset4_s64(svint64x4_t_val, 2, svint64_t_val); + svset4_u8(svuint8x4_t_val, 2, svuint8_t_val); + svset4_u16(svuint16x4_t_val, 2, svuint16_t_val); + svset4_u32(svuint32x4_t_val, 2, svuint32_t_val); + svset4_u64(svuint64x4_t_val, 2, svuint64_t_val); + svsplice(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsplice_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsqrt_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_f16_x(svbool_t_val, svfloat16_t_val); + svsqrt_f16_z(svbool_t_val, svfloat16_t_val); + svsqrt_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_f32_x(svbool_t_val, svfloat32_t_val); + svsqrt_f32_z(svbool_t_val, svfloat32_t_val); + svsqrt_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_f64_x(svbool_t_val, svfloat64_t_val); + svsqrt_f64_z(svbool_t_val, svfloat64_t_val); + svsqrt_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_x(svbool_t_val, svfloat16_t_val); + svsqrt_x(svbool_t_val, svfloat32_t_val); + svsqrt_x(svbool_t_val, svfloat64_t_val); + svsqrt_z(svbool_t_val, svfloat16_t_val); + svsqrt_z(svbool_t_val, svfloat32_t_val); + svsqrt_z(svbool_t_val, svfloat64_t_val); + svst1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_s16(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b_u16(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst2(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svstnt1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svstnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svsub_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svtbl(svbfloat16_t_val, svuint16_t_val); + svtbl(svfloat16_t_val, svuint16_t_val); + svtbl(svfloat32_t_val, svuint32_t_val); + svtbl(svfloat64_t_val, svuint64_t_val); + svtbl(svint8_t_val, svuint8_t_val); + svtbl(svint16_t_val, svuint16_t_val); + svtbl(svint32_t_val, svuint32_t_val); + svtbl(svint64_t_val, svuint64_t_val); + svtbl(svuint8_t_val, svuint8_t_val); + svtbl(svuint16_t_val, svuint16_t_val); + svtbl(svuint32_t_val, svuint32_t_val); + svtbl(svuint64_t_val, svuint64_t_val); + svtbl_bf16(svbfloat16_t_val, svuint16_t_val); + svtbl_f16(svfloat16_t_val, svuint16_t_val); + svtbl_f32(svfloat32_t_val, svuint32_t_val); + svtbl_f64(svfloat64_t_val, svuint64_t_val); + svtbl_s8(svint8_t_val, svuint8_t_val); + svtbl_s16(svint16_t_val, svuint16_t_val); + svtbl_s32(svint32_t_val, svuint32_t_val); + svtbl_s64(svint64_t_val, svuint64_t_val); + svtbl_u8(svuint8_t_val, svuint8_t_val); + svtbl_u16(svuint16_t_val, svuint16_t_val); + svtbl_u32(svuint32_t_val, svuint32_t_val); + svtbl_u64(svuint64_t_val, svuint64_t_val); + svtrn1(svbfloat16_t_val, svbfloat16_t_val); + svtrn1(svfloat16_t_val, svfloat16_t_val); + svtrn1(svfloat32_t_val, svfloat32_t_val); + svtrn1(svfloat64_t_val, svfloat64_t_val); + svtrn1(svint8_t_val, svint8_t_val); + svtrn1(svint16_t_val, svint16_t_val); + svtrn1(svint32_t_val, svint32_t_val); + svtrn1(svint64_t_val, svint64_t_val); + svtrn1(svuint8_t_val, svuint8_t_val); + svtrn1(svuint16_t_val, svuint16_t_val); + svtrn1(svuint32_t_val, svuint32_t_val); + svtrn1(svuint64_t_val, svuint64_t_val); + svtrn1_b8(svbool_t_val, svbool_t_val); + svtrn1_b16(svbool_t_val, svbool_t_val); + svtrn1_b32(svbool_t_val, svbool_t_val); + svtrn1_b64(svbool_t_val, svbool_t_val); + svtrn1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn1_f16(svfloat16_t_val, svfloat16_t_val); + svtrn1_f32(svfloat32_t_val, svfloat32_t_val); + svtrn1_f64(svfloat64_t_val, svfloat64_t_val); + svtrn1_s8(svint8_t_val, svint8_t_val); + svtrn1_s16(svint16_t_val, svint16_t_val); + svtrn1_s32(svint32_t_val, svint32_t_val); + svtrn1_s64(svint64_t_val, svint64_t_val); + svtrn1_u8(svuint8_t_val, svuint8_t_val); + svtrn1_u16(svuint16_t_val, svuint16_t_val); + svtrn1_u32(svuint32_t_val, svuint32_t_val); + svtrn1_u64(svuint64_t_val, svuint64_t_val); + svtrn2(svbfloat16_t_val, svbfloat16_t_val); + svtrn2(svfloat16_t_val, svfloat16_t_val); + svtrn2(svfloat32_t_val, svfloat32_t_val); + svtrn2(svfloat64_t_val, svfloat64_t_val); + svtrn2(svint8_t_val, svint8_t_val); + svtrn2(svint16_t_val, svint16_t_val); + svtrn2(svint32_t_val, svint32_t_val); + svtrn2(svint64_t_val, svint64_t_val); + svtrn2(svuint8_t_val, svuint8_t_val); + svtrn2(svuint16_t_val, svuint16_t_val); + svtrn2(svuint32_t_val, svuint32_t_val); + svtrn2(svuint64_t_val, svuint64_t_val); + svtrn2_b8(svbool_t_val, svbool_t_val); + svtrn2_b16(svbool_t_val, svbool_t_val); + svtrn2_b32(svbool_t_val, svbool_t_val); + svtrn2_b64(svbool_t_val, svbool_t_val); + svtrn2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn2_f16(svfloat16_t_val, svfloat16_t_val); + svtrn2_f32(svfloat32_t_val, svfloat32_t_val); + svtrn2_f64(svfloat64_t_val, svfloat64_t_val); + svtrn2_s8(svint8_t_val, svint8_t_val); + svtrn2_s16(svint16_t_val, svint16_t_val); + svtrn2_s32(svint32_t_val, svint32_t_val); + svtrn2_s64(svint64_t_val, svint64_t_val); + svtrn2_u8(svuint8_t_val, svuint8_t_val); + svtrn2_u16(svuint16_t_val, svuint16_t_val); + svtrn2_u32(svuint32_t_val, svuint32_t_val); + svtrn2_u64(svuint64_t_val, svuint64_t_val); + svundef2_bf16(); + svundef2_f16(); + svundef2_f32(); + svundef2_f64(); + svundef2_mf8(); + svundef2_s8(); + svundef2_s16(); + svundef2_s32(); + svundef2_s64(); + svundef2_u8(); + svundef2_u16(); + svundef2_u32(); + svundef2_u64(); + svundef3_bf16(); + svundef3_f16(); + svundef3_f32(); + svundef3_f64(); + svundef3_mf8(); + svundef3_s8(); + svundef3_s16(); + svundef3_s32(); + svundef3_s64(); + svundef3_u8(); + svundef3_u16(); + svundef3_u32(); + svundef3_u64(); + svundef4_bf16(); + svundef4_f16(); + svundef4_f32(); + svundef4_f64(); + svundef4_mf8(); + svundef4_s8(); + svundef4_s16(); + svundef4_s32(); + svundef4_s64(); + svundef4_u8(); + svundef4_u16(); + svundef4_u32(); + svundef4_u64(); + svundef_bf16(); + svundef_f16(); + svundef_f32(); + svundef_f64(); + svundef_mf8(); + svundef_s8(); + svundef_s16(); + svundef_s32(); + svundef_s64(); + svundef_u8(); + svundef_u16(); + svundef_u32(); + svundef_u64(); + svunpkhi(svbool_t_val); + svunpkhi(svint8_t_val); + svunpkhi(svint16_t_val); + svunpkhi(svint32_t_val); + svunpkhi(svuint8_t_val); + svunpkhi(svuint16_t_val); + svunpkhi(svuint32_t_val); + svunpkhi_b(svbool_t_val); + svunpkhi_s16(svint8_t_val); + svunpkhi_s32(svint16_t_val); + svunpkhi_s64(svint32_t_val); + svunpkhi_u16(svuint8_t_val); + svunpkhi_u32(svuint16_t_val); + svunpkhi_u64(svuint32_t_val); + svunpklo(svbool_t_val); + svunpklo(svint8_t_val); + svunpklo(svint16_t_val); + svunpklo(svint32_t_val); + svunpklo(svuint8_t_val); + svunpklo(svuint16_t_val); + svunpklo(svuint32_t_val); + svunpklo_b(svbool_t_val); + svunpklo_s16(svint8_t_val); + svunpklo_s32(svint16_t_val); + svunpklo_s64(svint32_t_val); + svunpklo_u16(svuint8_t_val); + svunpklo_u32(svuint16_t_val); + svunpklo_u64(svuint32_t_val); + svuzp1(svbfloat16_t_val, svbfloat16_t_val); + svuzp1(svfloat16_t_val, svfloat16_t_val); + svuzp1(svfloat32_t_val, svfloat32_t_val); + svuzp1(svfloat64_t_val, svfloat64_t_val); + svuzp1(svint8_t_val, svint8_t_val); + svuzp1(svint16_t_val, svint16_t_val); + svuzp1(svint32_t_val, svint32_t_val); + svuzp1(svint64_t_val, svint64_t_val); + svuzp1(svuint8_t_val, svuint8_t_val); + svuzp1(svuint16_t_val, svuint16_t_val); + svuzp1(svuint32_t_val, svuint32_t_val); + svuzp1(svuint64_t_val, svuint64_t_val); + svuzp1_b8(svbool_t_val, svbool_t_val); + svuzp1_b16(svbool_t_val, svbool_t_val); + svuzp1_b32(svbool_t_val, svbool_t_val); + svuzp1_b64(svbool_t_val, svbool_t_val); + svuzp1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp1_f16(svfloat16_t_val, svfloat16_t_val); + svuzp1_f32(svfloat32_t_val, svfloat32_t_val); + svuzp1_f64(svfloat64_t_val, svfloat64_t_val); + svuzp1_s8(svint8_t_val, svint8_t_val); + svuzp1_s16(svint16_t_val, svint16_t_val); + svuzp1_s32(svint32_t_val, svint32_t_val); + svuzp1_s64(svint64_t_val, svint64_t_val); + svuzp1_u8(svuint8_t_val, svuint8_t_val); + svuzp1_u16(svuint16_t_val, svuint16_t_val); + svuzp1_u32(svuint32_t_val, svuint32_t_val); + svuzp1_u64(svuint64_t_val, svuint64_t_val); + svuzp2(svbfloat16_t_val, svbfloat16_t_val); + svuzp2(svfloat16_t_val, svfloat16_t_val); + svuzp2(svfloat32_t_val, svfloat32_t_val); + svuzp2(svfloat64_t_val, svfloat64_t_val); + svuzp2(svint8_t_val, svint8_t_val); + svuzp2(svint16_t_val, svint16_t_val); + svuzp2(svint32_t_val, svint32_t_val); + svuzp2(svint64_t_val, svint64_t_val); + svuzp2(svuint8_t_val, svuint8_t_val); + svuzp2(svuint16_t_val, svuint16_t_val); + svuzp2(svuint32_t_val, svuint32_t_val); + svuzp2(svuint64_t_val, svuint64_t_val); + svuzp2_b8(svbool_t_val, svbool_t_val); + svuzp2_b16(svbool_t_val, svbool_t_val); + svuzp2_b32(svbool_t_val, svbool_t_val); + svuzp2_b64(svbool_t_val, svbool_t_val); + svuzp2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp2_f16(svfloat16_t_val, svfloat16_t_val); + svuzp2_f32(svfloat32_t_val, svfloat32_t_val); + svuzp2_f64(svfloat64_t_val, svfloat64_t_val); + svuzp2_s8(svint8_t_val, svint8_t_val); + svuzp2_s16(svint16_t_val, svint16_t_val); + svuzp2_s32(svint32_t_val, svint32_t_val); + svuzp2_s64(svint64_t_val, svint64_t_val); + svuzp2_u8(svuint8_t_val, svuint8_t_val); + svuzp2_u16(svuint16_t_val, svuint16_t_val); + svuzp2_u32(svuint32_t_val, svuint32_t_val); + svuzp2_u64(svuint64_t_val, svuint64_t_val); + svwhilele_b8(int32_t_val, int32_t_val); + svwhilele_b8(int64_t_val, int64_t_val); + svwhilele_b8(uint32_t_val, uint32_t_val); + svwhilele_b8(uint64_t_val, uint64_t_val); + svwhilele_b8_s32(int32_t_val, int32_t_val); + svwhilele_b8_s64(int64_t_val, int64_t_val); + svwhilele_b8_u32(uint32_t_val, uint32_t_val); + svwhilele_b8_u64(uint64_t_val, uint64_t_val); + svwhilele_b16(int32_t_val, int32_t_val); + svwhilele_b16(int64_t_val, int64_t_val); + svwhilele_b16(uint32_t_val, uint32_t_val); + svwhilele_b16(uint64_t_val, uint64_t_val); + svwhilele_b16_s32(int32_t_val, int32_t_val); + svwhilele_b16_s64(int64_t_val, int64_t_val); + svwhilele_b16_u32(uint32_t_val, uint32_t_val); + svwhilele_b16_u64(uint64_t_val, uint64_t_val); + svwhilele_b32(int32_t_val, int32_t_val); + svwhilele_b32(int64_t_val, int64_t_val); + svwhilele_b32(uint32_t_val, uint32_t_val); + svwhilele_b32(uint64_t_val, uint64_t_val); + svwhilele_b32_s32(int32_t_val, int32_t_val); + svwhilele_b32_s64(int64_t_val, int64_t_val); + svwhilele_b32_u32(uint32_t_val, uint32_t_val); + svwhilele_b32_u64(uint64_t_val, uint64_t_val); + svwhilele_b64(int32_t_val, int32_t_val); + svwhilele_b64(int64_t_val, int64_t_val); + svwhilele_b64(uint32_t_val, uint32_t_val); + svwhilele_b64(uint64_t_val, uint64_t_val); + svwhilele_b64_s32(int32_t_val, int32_t_val); + svwhilele_b64_s64(int64_t_val, int64_t_val); + svwhilele_b64_u32(uint32_t_val, uint32_t_val); + svwhilele_b64_u64(uint64_t_val, uint64_t_val); + svwhilelt_b8(int32_t_val, int32_t_val); + svwhilelt_b8(int64_t_val, int64_t_val); + svwhilelt_b8(uint32_t_val, uint32_t_val); + svwhilelt_b8(uint64_t_val, uint64_t_val); + svwhilelt_b8_s32(int32_t_val, int32_t_val); + svwhilelt_b8_s64(int64_t_val, int64_t_val); + svwhilelt_b8_u32(uint32_t_val, uint32_t_val); + svwhilelt_b8_u64(uint64_t_val, uint64_t_val); + svwhilelt_b16(int32_t_val, int32_t_val); + svwhilelt_b16(int64_t_val, int64_t_val); + svwhilelt_b16(uint32_t_val, uint32_t_val); + svwhilelt_b16(uint64_t_val, uint64_t_val); + svwhilelt_b16_s32(int32_t_val, int32_t_val); + svwhilelt_b16_s64(int64_t_val, int64_t_val); + svwhilelt_b16_u32(uint32_t_val, uint32_t_val); + svwhilelt_b16_u64(uint64_t_val, uint64_t_val); + svwhilelt_b32(int32_t_val, int32_t_val); + svwhilelt_b32(int64_t_val, int64_t_val); + svwhilelt_b32(uint32_t_val, uint32_t_val); + svwhilelt_b32(uint64_t_val, uint64_t_val); + svwhilelt_b32_s32(int32_t_val, int32_t_val); + svwhilelt_b32_s64(int64_t_val, int64_t_val); + svwhilelt_b32_u32(uint32_t_val, uint32_t_val); + svwhilelt_b32_u64(uint64_t_val, uint64_t_val); + svwhilelt_b64(int32_t_val, int32_t_val); + svwhilelt_b64(int64_t_val, int64_t_val); + svwhilelt_b64(uint32_t_val, uint32_t_val); + svwhilelt_b64(uint64_t_val, uint64_t_val); + svwhilelt_b64_s32(int32_t_val, int32_t_val); + svwhilelt_b64_s64(int64_t_val, int64_t_val); + svwhilelt_b64_u32(uint32_t_val, uint32_t_val); + svwhilelt_b64_u64(uint64_t_val, uint64_t_val); + svzip1(svbfloat16_t_val, svbfloat16_t_val); + svzip1(svfloat16_t_val, svfloat16_t_val); + svzip1(svfloat32_t_val, svfloat32_t_val); + svzip1(svfloat64_t_val, svfloat64_t_val); + svzip1(svint8_t_val, svint8_t_val); + svzip1(svint16_t_val, svint16_t_val); + svzip1(svint32_t_val, svint32_t_val); + svzip1(svint64_t_val, svint64_t_val); + svzip1(svuint8_t_val, svuint8_t_val); + svzip1(svuint16_t_val, svuint16_t_val); + svzip1(svuint32_t_val, svuint32_t_val); + svzip1(svuint64_t_val, svuint64_t_val); + svzip1_b8(svbool_t_val, svbool_t_val); + svzip1_b16(svbool_t_val, svbool_t_val); + svzip1_b32(svbool_t_val, svbool_t_val); + svzip1_b64(svbool_t_val, svbool_t_val); + svzip1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip1_f16(svfloat16_t_val, svfloat16_t_val); + svzip1_f32(svfloat32_t_val, svfloat32_t_val); + svzip1_f64(svfloat64_t_val, svfloat64_t_val); + svzip1_s8(svint8_t_val, svint8_t_val); + svzip1_s16(svint16_t_val, svint16_t_val); + svzip1_s32(svint32_t_val, svint32_t_val); + svzip1_s64(svint64_t_val, svint64_t_val); + svzip1_u8(svuint8_t_val, svuint8_t_val); + svzip1_u16(svuint16_t_val, svuint16_t_val); + svzip1_u32(svuint32_t_val, svuint32_t_val); + svzip1_u64(svuint64_t_val, svuint64_t_val); + svzip2(svbfloat16_t_val, svbfloat16_t_val); + svzip2(svfloat16_t_val, svfloat16_t_val); + svzip2(svfloat32_t_val, svfloat32_t_val); + svzip2(svfloat64_t_val, svfloat64_t_val); + svzip2(svint8_t_val, svint8_t_val); + svzip2(svint16_t_val, svint16_t_val); + svzip2(svint32_t_val, svint32_t_val); + svzip2(svint64_t_val, svint64_t_val); + svzip2(svuint8_t_val, svuint8_t_val); + svzip2(svuint16_t_val, svuint16_t_val); + svzip2(svuint32_t_val, svuint32_t_val); + svzip2(svuint64_t_val, svuint64_t_val); + svzip2_b8(svbool_t_val, svbool_t_val); + svzip2_b16(svbool_t_val, svbool_t_val); + svzip2_b32(svbool_t_val, svbool_t_val); + svzip2_b64(svbool_t_val, svbool_t_val); + svzip2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip2_f16(svfloat16_t_val, svfloat16_t_val); + svzip2_f32(svfloat32_t_val, svfloat32_t_val); + svzip2_f64(svfloat64_t_val, svfloat64_t_val); + svzip2_s8(svint8_t_val, svint8_t_val); + svzip2_s16(svint16_t_val, svint16_t_val); + svzip2_s32(svint32_t_val, svint32_t_val); + svzip2_s64(svint64_t_val, svint64_t_val); + svzip2_u8(svuint8_t_val, svuint8_t_val); + svzip2_u16(svuint16_t_val, svuint16_t_val); + svzip2_u32(svuint32_t_val, svuint32_t_val); + svzip2_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + bfloat16_t bfloat16_t_val; + bool bool_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int8_t int8_t_val; + int16_t * int16_t_ptr_val; + int16_t int16_t_val; + int32_t * int32_t_ptr_val; + int32_t int32_t_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x3_t svbfloat16x3_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x3_t svfloat16x3_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x3_t svfloat32x3_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x3_t svfloat64x3_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x3_t svint8x3_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x3_t svint16x3_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x3_t svint32x3_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x3_t svint64x3_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x3_t svmfloat8x3_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x3_t svuint8x3_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x3_t svuint16x3_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x3_t svuint32x3_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x3_t svuint64x3_t_val; + svuint64x4_t svuint64x4_t_val; + uint8_t * uint8_t_ptr_val; + uint8_t uint8_t_val; + uint16_t * uint16_t_ptr_val; + uint16_t uint16_t_val; + uint32_t * uint32_t_ptr_val; + uint32_t uint32_t_val; + uint64_t * uint64_t_ptr_val; + uint64_t uint64_t_val; + void * void_ptr_val; + + svabd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_x(svbool_t_val, svint8_t_val, int8_t_val); + svabd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_x(svbool_t_val, svint16_t_val, int16_t_val); + svabd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_x(svbool_t_val, svint32_t_val, int32_t_val); + svabd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_x(svbool_t_val, svint64_t_val, int64_t_val); + svabd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svabd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svabd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svabd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svabd_z(svbool_t_val, svint8_t_val, int8_t_val); + svabd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svabd_z(svbool_t_val, svint16_t_val, int16_t_val); + svabd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svabd_z(svbool_t_val, svint32_t_val, int32_t_val); + svabd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svabd_z(svbool_t_val, svint64_t_val, int64_t_val); + svabd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svabd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svabd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svabd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svabd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svabd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svabd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svabd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svabd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svabs_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_f16_x(svbool_t_val, svfloat16_t_val); + svabs_f16_z(svbool_t_val, svfloat16_t_val); + svabs_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_f32_x(svbool_t_val, svfloat32_t_val); + svabs_f32_z(svbool_t_val, svfloat32_t_val); + svabs_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_f64_x(svbool_t_val, svfloat64_t_val); + svabs_f64_z(svbool_t_val, svfloat64_t_val); + svabs_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svabs_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svabs_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svabs_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svabs_s8_x(svbool_t_val, svint8_t_val); + svabs_s8_z(svbool_t_val, svint8_t_val); + svabs_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svabs_s16_x(svbool_t_val, svint16_t_val); + svabs_s16_z(svbool_t_val, svint16_t_val); + svabs_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svabs_s32_x(svbool_t_val, svint32_t_val); + svabs_s32_z(svbool_t_val, svint32_t_val); + svabs_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svabs_s64_x(svbool_t_val, svint64_t_val); + svabs_s64_z(svbool_t_val, svint64_t_val); + svabs_x(svbool_t_val, svfloat16_t_val); + svabs_x(svbool_t_val, svfloat32_t_val); + svabs_x(svbool_t_val, svfloat64_t_val); + svabs_x(svbool_t_val, svint8_t_val); + svabs_x(svbool_t_val, svint16_t_val); + svabs_x(svbool_t_val, svint32_t_val); + svabs_x(svbool_t_val, svint64_t_val); + svabs_z(svbool_t_val, svfloat16_t_val); + svabs_z(svbool_t_val, svfloat32_t_val); + svabs_z(svbool_t_val, svfloat64_t_val); + svabs_z(svbool_t_val, svint8_t_val); + svabs_z(svbool_t_val, svint16_t_val); + svabs_z(svbool_t_val, svint32_t_val); + svabs_z(svbool_t_val, svint64_t_val); + svacge(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge(svbool_t_val, svfloat64_t_val, float64_t_val); + svacge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svacgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle(svbool_t_val, svfloat64_t_val, float64_t_val); + svacle(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svacle_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svacle_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svacle_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svacle_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svacle_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt(svbool_t_val, svfloat64_t_val, float64_t_val); + svaclt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svaclt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svaclt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svaclt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svaclt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svaclt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_x(svbool_t_val, svint8_t_val, int8_t_val); + svadd_x(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_x(svbool_t_val, svint16_t_val, int16_t_val); + svadd_x(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_x(svbool_t_val, svint32_t_val, int32_t_val); + svadd_x(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_x(svbool_t_val, svint64_t_val, int64_t_val); + svadd_x(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svadd_z(svbool_t_val, svint8_t_val, int8_t_val); + svadd_z(svbool_t_val, svint8_t_val, svint8_t_val); + svadd_z(svbool_t_val, svint16_t_val, int16_t_val); + svadd_z(svbool_t_val, svint16_t_val, svint16_t_val); + svadd_z(svbool_t_val, svint32_t_val, int32_t_val); + svadd_z(svbool_t_val, svint32_t_val, svint32_t_val); + svadd_z(svbool_t_val, svint64_t_val, int64_t_val); + svadd_z(svbool_t_val, svint64_t_val, svint64_t_val); + svadd_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svadd_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svadd_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svadd_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svadd_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svadd_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svadd_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svadd_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svaddv(svbool_t_val, svfloat16_t_val); + svaddv(svbool_t_val, svfloat32_t_val); + svaddv(svbool_t_val, svfloat64_t_val); + svaddv(svbool_t_val, svint8_t_val); + svaddv(svbool_t_val, svint16_t_val); + svaddv(svbool_t_val, svint32_t_val); + svaddv(svbool_t_val, svint64_t_val); + svaddv(svbool_t_val, svuint8_t_val); + svaddv(svbool_t_val, svuint16_t_val); + svaddv(svbool_t_val, svuint32_t_val); + svaddv(svbool_t_val, svuint64_t_val); + svaddv_f16(svbool_t_val, svfloat16_t_val); + svaddv_f32(svbool_t_val, svfloat32_t_val); + svaddv_f64(svbool_t_val, svfloat64_t_val); + svaddv_s8(svbool_t_val, svint8_t_val); + svaddv_s16(svbool_t_val, svint16_t_val); + svaddv_s32(svbool_t_val, svint32_t_val); + svaddv_s64(svbool_t_val, svint64_t_val); + svaddv_u8(svbool_t_val, svuint8_t_val); + svaddv_u16(svbool_t_val, svuint16_t_val); + svaddv_u32(svbool_t_val, svuint32_t_val); + svaddv_u64(svbool_t_val, svuint64_t_val); + svand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svint8_t_val, int8_t_val); + svand_x(svbool_t_val, svint8_t_val, svint8_t_val); + svand_x(svbool_t_val, svint16_t_val, int16_t_val); + svand_x(svbool_t_val, svint16_t_val, svint16_t_val); + svand_x(svbool_t_val, svint32_t_val, int32_t_val); + svand_x(svbool_t_val, svint32_t_val, svint32_t_val); + svand_x(svbool_t_val, svint64_t_val, int64_t_val); + svand_x(svbool_t_val, svint64_t_val, svint64_t_val); + svand_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svand_z(svbool_t_val, svint8_t_val, int8_t_val); + svand_z(svbool_t_val, svint8_t_val, svint8_t_val); + svand_z(svbool_t_val, svint16_t_val, int16_t_val); + svand_z(svbool_t_val, svint16_t_val, svint16_t_val); + svand_z(svbool_t_val, svint32_t_val, int32_t_val); + svand_z(svbool_t_val, svint32_t_val, svint32_t_val); + svand_z(svbool_t_val, svint64_t_val, int64_t_val); + svand_z(svbool_t_val, svint64_t_val, svint64_t_val); + svand_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svand_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svand_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svand_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svand_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svand_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svand_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svand_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svandv(svbool_t_val, svint8_t_val); + svandv(svbool_t_val, svint16_t_val); + svandv(svbool_t_val, svint32_t_val); + svandv(svbool_t_val, svint64_t_val); + svandv(svbool_t_val, svuint8_t_val); + svandv(svbool_t_val, svuint16_t_val); + svandv(svbool_t_val, svuint32_t_val); + svandv(svbool_t_val, svuint64_t_val); + svandv_s8(svbool_t_val, svint8_t_val); + svandv_s16(svbool_t_val, svint16_t_val); + svandv_s32(svbool_t_val, svint32_t_val); + svandv_s64(svbool_t_val, svint64_t_val); + svandv_u8(svbool_t_val, svuint8_t_val); + svandv_u16(svbool_t_val, svuint16_t_val); + svandv_u32(svbool_t_val, svuint32_t_val); + svandv_u64(svbool_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svasr_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svasr_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_x(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_x(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_x(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_x(svbool_t_val, svint64_t_val, uint64_t_val); + svasr_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svasr_z(svbool_t_val, svint8_t_val, uint8_t_val); + svasr_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svasr_z(svbool_t_val, svint16_t_val, uint16_t_val); + svasr_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svasr_z(svbool_t_val, svint32_t_val, uint32_t_val); + svasr_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svasr_z(svbool_t_val, svint64_t_val, uint64_t_val); + svasrd_m(svbool_t_val, svint8_t_val, 2); + svasrd_m(svbool_t_val, svint16_t_val, 2); + svasrd_m(svbool_t_val, svint32_t_val, 2); + svasrd_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s8_m(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_x(svbool_t_val, svint8_t_val, 2); + svasrd_n_s8_z(svbool_t_val, svint8_t_val, 2); + svasrd_n_s16_m(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_x(svbool_t_val, svint16_t_val, 2); + svasrd_n_s16_z(svbool_t_val, svint16_t_val, 2); + svasrd_n_s32_m(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_x(svbool_t_val, svint32_t_val, 2); + svasrd_n_s32_z(svbool_t_val, svint32_t_val, 2); + svasrd_n_s64_m(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_x(svbool_t_val, svint64_t_val, 2); + svasrd_n_s64_z(svbool_t_val, svint64_t_val, 2); + svasrd_x(svbool_t_val, svint8_t_val, 2); + svasrd_x(svbool_t_val, svint16_t_val, 2); + svasrd_x(svbool_t_val, svint32_t_val, 2); + svasrd_x(svbool_t_val, svint64_t_val, 2); + svasrd_z(svbool_t_val, svint8_t_val, 2); + svasrd_z(svbool_t_val, svint16_t_val, 2); + svasrd_z(svbool_t_val, svint32_t_val, 2); + svasrd_z(svbool_t_val, svint64_t_val, 2); + svbic_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svint8_t_val, int8_t_val); + svbic_x(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_x(svbool_t_val, svint16_t_val, int16_t_val); + svbic_x(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_x(svbool_t_val, svint32_t_val, int32_t_val); + svbic_x(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_x(svbool_t_val, svint64_t_val, int64_t_val); + svbic_x(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svbic_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbic_z(svbool_t_val, svint8_t_val, int8_t_val); + svbic_z(svbool_t_val, svint8_t_val, svint8_t_val); + svbic_z(svbool_t_val, svint16_t_val, int16_t_val); + svbic_z(svbool_t_val, svint16_t_val, svint16_t_val); + svbic_z(svbool_t_val, svint32_t_val, int32_t_val); + svbic_z(svbool_t_val, svint32_t_val, svint32_t_val); + svbic_z(svbool_t_val, svint64_t_val, int64_t_val); + svbic_z(svbool_t_val, svint64_t_val, svint64_t_val); + svbic_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svbic_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svbic_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svbic_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svbic_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svbic_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svbic_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svbic_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svbrka_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_b_z(svbool_t_val, svbool_t_val); + svbrka_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrka_z(svbool_t_val, svbool_t_val); + svbrkb_b_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_b_z(svbool_t_val, svbool_t_val); + svbrkb_m(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkb_z(svbool_t_val, svbool_t_val); + svbrkn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpa_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svbrkpb_z(svbool_t_val, svbool_t_val, svbool_t_val); + svcadd_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcadd_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcadd_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcadd_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svclasta(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, int8_t_val, svint8_t_val); + svclasta(svbool_t_val, int16_t_val, svint16_t_val); + svclasta(svbool_t_val, int32_t_val, svint32_t_val); + svclasta(svbool_t_val, int64_t_val, svint64_t_val); + svclasta(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclasta(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclasta_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclasta_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclasta_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclasta_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclasta_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclasta_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclasta_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclasta_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclasta_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclasta_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclasta_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclasta_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclasta_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclasta_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclasta_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclasta_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclasta_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclasta_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclasta_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclasta_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclasta_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclasta_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclasta_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, int8_t_val, svint8_t_val); + svclastb(svbool_t_val, int16_t_val, svint16_t_val); + svclastb(svbool_t_val, int32_t_val, svint32_t_val); + svclastb(svbool_t_val, int64_t_val, svint64_t_val); + svclastb(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, svuint64_t_val, svuint64_t_val); + svclastb(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclastb_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svclastb_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svclastb_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svclastb_n_bf16(svbool_t_val, bfloat16_t_val, svbfloat16_t_val); + svclastb_n_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svclastb_n_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svclastb_n_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svclastb_n_s8(svbool_t_val, int8_t_val, svint8_t_val); + svclastb_n_s16(svbool_t_val, int16_t_val, svint16_t_val); + svclastb_n_s32(svbool_t_val, int32_t_val, svint32_t_val); + svclastb_n_s64(svbool_t_val, int64_t_val, svint64_t_val); + svclastb_n_u8(svbool_t_val, uint8_t_val, svuint8_t_val); + svclastb_n_u16(svbool_t_val, uint16_t_val, svuint16_t_val); + svclastb_n_u32(svbool_t_val, uint32_t_val, svuint32_t_val); + svclastb_n_u64(svbool_t_val, uint64_t_val, svuint64_t_val); + svclastb_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svclastb_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svclastb_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svclastb_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svclastb_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svclastb_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svclastb_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svclastb_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcls_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcls_s8_x(svbool_t_val, svint8_t_val); + svcls_s8_z(svbool_t_val, svint8_t_val); + svcls_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcls_s16_x(svbool_t_val, svint16_t_val); + svcls_s16_z(svbool_t_val, svint16_t_val); + svcls_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcls_s32_x(svbool_t_val, svint32_t_val); + svcls_s32_z(svbool_t_val, svint32_t_val); + svcls_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcls_s64_x(svbool_t_val, svint64_t_val); + svcls_s64_z(svbool_t_val, svint64_t_val); + svcls_x(svbool_t_val, svint8_t_val); + svcls_x(svbool_t_val, svint16_t_val); + svcls_x(svbool_t_val, svint32_t_val); + svcls_x(svbool_t_val, svint64_t_val); + svcls_z(svbool_t_val, svint8_t_val); + svcls_z(svbool_t_val, svint16_t_val); + svcls_z(svbool_t_val, svint32_t_val); + svcls_z(svbool_t_val, svint64_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svclz_s8_x(svbool_t_val, svint8_t_val); + svclz_s8_z(svbool_t_val, svint8_t_val); + svclz_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svclz_s16_x(svbool_t_val, svint16_t_val); + svclz_s16_z(svbool_t_val, svint16_t_val); + svclz_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svclz_s32_x(svbool_t_val, svint32_t_val); + svclz_s32_z(svbool_t_val, svint32_t_val); + svclz_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svclz_s64_x(svbool_t_val, svint64_t_val); + svclz_s64_z(svbool_t_val, svint64_t_val); + svclz_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svclz_u8_x(svbool_t_val, svuint8_t_val); + svclz_u8_z(svbool_t_val, svuint8_t_val); + svclz_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svclz_u16_x(svbool_t_val, svuint16_t_val); + svclz_u16_z(svbool_t_val, svuint16_t_val); + svclz_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svclz_u32_x(svbool_t_val, svuint32_t_val); + svclz_u32_z(svbool_t_val, svuint32_t_val); + svclz_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svclz_u64_x(svbool_t_val, svuint64_t_val); + svclz_u64_z(svbool_t_val, svuint64_t_val); + svclz_x(svbool_t_val, svint8_t_val); + svclz_x(svbool_t_val, svint16_t_val); + svclz_x(svbool_t_val, svint32_t_val); + svclz_x(svbool_t_val, svint64_t_val); + svclz_x(svbool_t_val, svuint8_t_val); + svclz_x(svbool_t_val, svuint16_t_val); + svclz_x(svbool_t_val, svuint32_t_val); + svclz_x(svbool_t_val, svuint64_t_val); + svclz_z(svbool_t_val, svint8_t_val); + svclz_z(svbool_t_val, svint16_t_val); + svclz_z(svbool_t_val, svint32_t_val); + svclz_z(svbool_t_val, svint64_t_val); + svclz_z(svbool_t_val, svuint8_t_val); + svclz_z(svbool_t_val, svuint16_t_val); + svclz_z(svbool_t_val, svuint32_t_val); + svclz_z(svbool_t_val, svuint64_t_val); + svcmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1, 90); + svcmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1, 90); + svcmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 90); + svcmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 90); + svcmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 90); + svcmpeq(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpeq_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpeq_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpeq_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpeq_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpeq_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpeq_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpeq_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpeq_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpeq_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpeq_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpeq_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpeq_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpeq_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpeq_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpeq_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpeq_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpeq_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpeq_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpeq_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpeq_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpeq_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpeq_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpeq_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpeq_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpeq_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpeq_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpeq_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpge_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpge_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpge_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpge_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpge_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpge_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpge_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpge_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpge_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpge_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpge_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpge_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpge_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpge_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpge_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpge_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpge_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpge_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpge_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpge_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpge_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpge_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpge_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpge_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpge_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpge_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpge_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpge_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpge_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpge_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpge_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpge_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpge_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpgt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpgt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpgt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpgt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpgt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpgt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpgt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpgt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpgt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpgt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpgt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpgt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpgt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpgt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpgt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpgt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpgt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpgt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpgt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpgt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpgt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpgt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpgt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpgt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpgt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmpgt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmpgt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmpgt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpgt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpgt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpgt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmpgt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmpgt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple(svbool_t_val, svint8_t_val, int8_t_val); + svcmple(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple(svbool_t_val, svint16_t_val, int16_t_val); + svcmple(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple(svbool_t_val, svint32_t_val, int32_t_val); + svcmple(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple(svbool_t_val, svint64_t_val, int64_t_val); + svcmple(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmple_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmple_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmple_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmple_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmple_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmple_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmple_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmple_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmple_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmple_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmple_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmple_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmple_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmple_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmple_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmple_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmple_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmple_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmple_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmple_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmple_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmple_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmple_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmple_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmple_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmple_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmple_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmple_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmple_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmple_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmple_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmple_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmple_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmplt_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmplt_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmplt_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmplt_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmplt_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmplt_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmplt_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmplt_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmplt_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmplt_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmplt_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmplt_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmplt_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmplt_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmplt_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmplt_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmplt_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmplt_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmplt_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmplt_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmplt_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmplt_wide(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmplt_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmplt_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmplt_wide_n_u8(svbool_t_val, svuint8_t_val, uint64_t_val); + svcmplt_wide_n_u16(svbool_t_val, svuint16_t_val, uint64_t_val); + svcmplt_wide_n_u32(svbool_t_val, svuint32_t_val, uint64_t_val); + svcmplt_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmplt_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmplt_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmplt_wide_u8(svbool_t_val, svuint8_t_val, svuint64_t_val); + svcmplt_wide_u16(svbool_t_val, svuint16_t_val, svuint64_t_val); + svcmplt_wide_u32(svbool_t_val, svuint32_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpne_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpne_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpne_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpne_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpne_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpne_n_s8(svbool_t_val, svint8_t_val, int8_t_val); + svcmpne_n_s16(svbool_t_val, svint16_t_val, int16_t_val); + svcmpne_n_s32(svbool_t_val, svint32_t_val, int32_t_val); + svcmpne_n_s64(svbool_t_val, svint64_t_val, int64_t_val); + svcmpne_n_u8(svbool_t_val, svuint8_t_val, uint8_t_val); + svcmpne_n_u16(svbool_t_val, svuint16_t_val, uint16_t_val); + svcmpne_n_u32(svbool_t_val, svuint32_t_val, uint32_t_val); + svcmpne_n_u64(svbool_t_val, svuint64_t_val, uint64_t_val); + svcmpne_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svcmpne_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svcmpne_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svcmpne_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svcmpne_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svcmpne_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svcmpne_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svcmpne_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpne_wide_n_s8(svbool_t_val, svint8_t_val, int64_t_val); + svcmpne_wide_n_s16(svbool_t_val, svint16_t_val, int64_t_val); + svcmpne_wide_n_s32(svbool_t_val, svint32_t_val, int64_t_val); + svcmpne_wide_s8(svbool_t_val, svint8_t_val, svint64_t_val); + svcmpne_wide_s16(svbool_t_val, svint16_t_val, svint64_t_val); + svcmpne_wide_s32(svbool_t_val, svint32_t_val, svint64_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, float64_t_val); + svcmpuo(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svcmpuo_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svcmpuo_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svcmpuo_n_f16(svbool_t_val, svfloat16_t_val, float16_t_val); + svcmpuo_n_f32(svbool_t_val, svfloat32_t_val, float32_t_val); + svcmpuo_n_f64(svbool_t_val, svfloat64_t_val, float64_t_val); + svcnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svcnot_s8_x(svbool_t_val, svint8_t_val); + svcnot_s8_z(svbool_t_val, svint8_t_val); + svcnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svcnot_s16_x(svbool_t_val, svint16_t_val); + svcnot_s16_z(svbool_t_val, svint16_t_val); + svcnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svcnot_s32_x(svbool_t_val, svint32_t_val); + svcnot_s32_z(svbool_t_val, svint32_t_val); + svcnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svcnot_s64_x(svbool_t_val, svint64_t_val); + svcnot_s64_z(svbool_t_val, svint64_t_val); + svcnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnot_u8_x(svbool_t_val, svuint8_t_val); + svcnot_u8_z(svbool_t_val, svuint8_t_val); + svcnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnot_u16_x(svbool_t_val, svuint16_t_val); + svcnot_u16_z(svbool_t_val, svuint16_t_val); + svcnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnot_u32_x(svbool_t_val, svuint32_t_val); + svcnot_u32_z(svbool_t_val, svuint32_t_val); + svcnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnot_u64_x(svbool_t_val, svuint64_t_val); + svcnot_u64_z(svbool_t_val, svuint64_t_val); + svcnot_x(svbool_t_val, svint8_t_val); + svcnot_x(svbool_t_val, svint16_t_val); + svcnot_x(svbool_t_val, svint32_t_val); + svcnot_x(svbool_t_val, svint64_t_val); + svcnot_x(svbool_t_val, svuint8_t_val); + svcnot_x(svbool_t_val, svuint16_t_val); + svcnot_x(svbool_t_val, svuint32_t_val); + svcnot_x(svbool_t_val, svuint64_t_val); + svcnot_z(svbool_t_val, svint8_t_val); + svcnot_z(svbool_t_val, svint16_t_val); + svcnot_z(svbool_t_val, svint32_t_val); + svcnot_z(svbool_t_val, svint64_t_val); + svcnot_z(svbool_t_val, svuint8_t_val); + svcnot_z(svbool_t_val, svuint16_t_val); + svcnot_z(svbool_t_val, svuint32_t_val); + svcnot_z(svbool_t_val, svuint64_t_val); + svcnt_bf16_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_bf16_x(svbool_t_val, svbfloat16_t_val); + svcnt_bf16_z(svbool_t_val, svbfloat16_t_val); + svcnt_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_f16_x(svbool_t_val, svfloat16_t_val); + svcnt_f16_z(svbool_t_val, svfloat16_t_val); + svcnt_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_f32_x(svbool_t_val, svfloat32_t_val); + svcnt_f32_z(svbool_t_val, svfloat32_t_val); + svcnt_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_f64_x(svbool_t_val, svfloat64_t_val); + svcnt_f64_z(svbool_t_val, svfloat64_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svbfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_s8_m(svuint8_t_val, svbool_t_val, svint8_t_val); + svcnt_s8_x(svbool_t_val, svint8_t_val); + svcnt_s8_z(svbool_t_val, svint8_t_val); + svcnt_s16_m(svuint16_t_val, svbool_t_val, svint16_t_val); + svcnt_s16_x(svbool_t_val, svint16_t_val); + svcnt_s16_z(svbool_t_val, svint16_t_val); + svcnt_s32_m(svuint32_t_val, svbool_t_val, svint32_t_val); + svcnt_s32_x(svbool_t_val, svint32_t_val); + svcnt_s32_z(svbool_t_val, svint32_t_val); + svcnt_s64_m(svuint64_t_val, svbool_t_val, svint64_t_val); + svcnt_s64_x(svbool_t_val, svint64_t_val); + svcnt_s64_z(svbool_t_val, svint64_t_val); + svcnt_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svcnt_u8_x(svbool_t_val, svuint8_t_val); + svcnt_u8_z(svbool_t_val, svuint8_t_val); + svcnt_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svcnt_u16_x(svbool_t_val, svuint16_t_val); + svcnt_u16_z(svbool_t_val, svuint16_t_val); + svcnt_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svcnt_u32_x(svbool_t_val, svuint32_t_val); + svcnt_u32_z(svbool_t_val, svuint32_t_val); + svcnt_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svcnt_u64_x(svbool_t_val, svuint64_t_val); + svcnt_u64_z(svbool_t_val, svuint64_t_val); + svcnt_x(svbool_t_val, svbfloat16_t_val); + svcnt_x(svbool_t_val, svfloat16_t_val); + svcnt_x(svbool_t_val, svfloat32_t_val); + svcnt_x(svbool_t_val, svfloat64_t_val); + svcnt_x(svbool_t_val, svint8_t_val); + svcnt_x(svbool_t_val, svint16_t_val); + svcnt_x(svbool_t_val, svint32_t_val); + svcnt_x(svbool_t_val, svint64_t_val); + svcnt_x(svbool_t_val, svuint8_t_val); + svcnt_x(svbool_t_val, svuint16_t_val); + svcnt_x(svbool_t_val, svuint32_t_val); + svcnt_x(svbool_t_val, svuint64_t_val); + svcnt_z(svbool_t_val, svbfloat16_t_val); + svcnt_z(svbool_t_val, svfloat16_t_val); + svcnt_z(svbool_t_val, svfloat32_t_val); + svcnt_z(svbool_t_val, svfloat64_t_val); + svcnt_z(svbool_t_val, svint8_t_val); + svcnt_z(svbool_t_val, svint16_t_val); + svcnt_z(svbool_t_val, svint32_t_val); + svcnt_z(svbool_t_val, svint64_t_val); + svcnt_z(svbool_t_val, svuint8_t_val); + svcnt_z(svbool_t_val, svuint16_t_val); + svcnt_z(svbool_t_val, svuint32_t_val); + svcnt_z(svbool_t_val, svuint64_t_val); + svcntb(); + svcntb_pat(SV_MUL3); + svcntd(); + svcntd_pat(SV_MUL3); + svcnth(); + svcnth_pat(SV_MUL3); + svcntp_b8(svbool_t_val, svbool_t_val); + svcntp_b16(svbool_t_val, svbool_t_val); + svcntp_b32(svbool_t_val, svbool_t_val); + svcntp_b64(svbool_t_val, svbool_t_val); + svcntw(); + svcntw_pat(SV_MUL3); + svcreate2(svbfloat16_t_val, svbfloat16_t_val); + svcreate2(svfloat16_t_val, svfloat16_t_val); + svcreate2(svfloat32_t_val, svfloat32_t_val); + svcreate2(svfloat64_t_val, svfloat64_t_val); + svcreate2(svint8_t_val, svint8_t_val); + svcreate2(svint16_t_val, svint16_t_val); + svcreate2(svint32_t_val, svint32_t_val); + svcreate2(svint64_t_val, svint64_t_val); + svcreate2(svmfloat8_t_val, svmfloat8_t_val); + svcreate2(svuint8_t_val, svuint8_t_val); + svcreate2(svuint16_t_val, svuint16_t_val); + svcreate2(svuint32_t_val, svuint32_t_val); + svcreate2(svuint64_t_val, svuint64_t_val); + svcreate2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svcreate2_f16(svfloat16_t_val, svfloat16_t_val); + svcreate2_f32(svfloat32_t_val, svfloat32_t_val); + svcreate2_f64(svfloat64_t_val, svfloat64_t_val); + svcreate2_mf8(svmfloat8_t_val, svmfloat8_t_val); + svcreate2_s8(svint8_t_val, svint8_t_val); + svcreate2_s16(svint16_t_val, svint16_t_val); + svcreate2_s32(svint32_t_val, svint32_t_val); + svcreate2_s64(svint64_t_val, svint64_t_val); + svcreate2_u8(svuint8_t_val, svuint8_t_val); + svcreate2_u16(svuint16_t_val, svuint16_t_val); + svcreate2_u32(svuint32_t_val, svuint32_t_val); + svcreate2_u64(svuint64_t_val, svuint64_t_val); + svcreate3(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate3_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate3_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate3_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate3_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate3_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate3_s8(svint8_t_val, svint8_t_val, svint8_t_val); + svcreate3_s16(svint16_t_val, svint16_t_val, svint16_t_val); + svcreate3_s32(svint32_t_val, svint32_t_val, svint32_t_val); + svcreate3_s64(svint64_t_val, svint64_t_val, svint64_t_val); + svcreate3_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate3_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate3_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate3_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcreate4_bf16(svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val, svbfloat16_t_val); + svcreate4_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svcreate4_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svcreate4_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svcreate4_mf8(svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val, svmfloat8_t_val); + svcreate4_s8(svint8_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svcreate4_s16(svint16_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svcreate4_s32(svint32_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svcreate4_s64(svint64_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svcreate4_u8(svuint8_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svcreate4_u16(svuint16_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svcreate4_u32(svuint32_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svcreate4_u64(svuint64_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svcvt_f16_f32_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_f64_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_s16_m(svfloat16_t_val, svbool_t_val, svint16_t_val); + svcvt_f16_s16_x(svbool_t_val, svint16_t_val); + svcvt_f16_s16_z(svbool_t_val, svint16_t_val); + svcvt_f16_s32_m(svfloat16_t_val, svbool_t_val, svint32_t_val); + svcvt_f16_s32_x(svbool_t_val, svint32_t_val); + svcvt_f16_s32_z(svbool_t_val, svint32_t_val); + svcvt_f16_s64_m(svfloat16_t_val, svbool_t_val, svint64_t_val); + svcvt_f16_s64_x(svbool_t_val, svint64_t_val); + svcvt_f16_s64_z(svbool_t_val, svint64_t_val); + svcvt_f16_u16_m(svfloat16_t_val, svbool_t_val, svuint16_t_val); + svcvt_f16_u16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_u16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_u32_m(svfloat16_t_val, svbool_t_val, svuint32_t_val); + svcvt_f16_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f16_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f16_u64_m(svfloat16_t_val, svbool_t_val, svuint64_t_val); + svcvt_f16_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f16_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f16_x(svbool_t_val, svfloat32_t_val); + svcvt_f16_x(svbool_t_val, svfloat64_t_val); + svcvt_f16_x(svbool_t_val, svint16_t_val); + svcvt_f16_x(svbool_t_val, svint32_t_val); + svcvt_f16_x(svbool_t_val, svint64_t_val); + svcvt_f16_x(svbool_t_val, svuint16_t_val); + svcvt_f16_x(svbool_t_val, svuint32_t_val); + svcvt_f16_x(svbool_t_val, svuint64_t_val); + svcvt_f16_z(svbool_t_val, svfloat32_t_val); + svcvt_f16_z(svbool_t_val, svfloat64_t_val); + svcvt_f16_z(svbool_t_val, svint16_t_val); + svcvt_f16_z(svbool_t_val, svint32_t_val); + svcvt_f16_z(svbool_t_val, svint64_t_val); + svcvt_f16_z(svbool_t_val, svuint16_t_val); + svcvt_f16_z(svbool_t_val, svuint32_t_val); + svcvt_f16_z(svbool_t_val, svuint64_t_val); + svcvt_f32_f16_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_f64_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_s32_m(svfloat32_t_val, svbool_t_val, svint32_t_val); + svcvt_f32_s32_x(svbool_t_val, svint32_t_val); + svcvt_f32_s32_z(svbool_t_val, svint32_t_val); + svcvt_f32_s64_m(svfloat32_t_val, svbool_t_val, svint64_t_val); + svcvt_f32_s64_x(svbool_t_val, svint64_t_val); + svcvt_f32_s64_z(svbool_t_val, svint64_t_val); + svcvt_f32_u32_m(svfloat32_t_val, svbool_t_val, svuint32_t_val); + svcvt_f32_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_u64_m(svfloat32_t_val, svbool_t_val, svuint64_t_val); + svcvt_f32_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f32_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f32_x(svbool_t_val, svfloat16_t_val); + svcvt_f32_x(svbool_t_val, svfloat64_t_val); + svcvt_f32_x(svbool_t_val, svint32_t_val); + svcvt_f32_x(svbool_t_val, svint64_t_val); + svcvt_f32_x(svbool_t_val, svuint32_t_val); + svcvt_f32_x(svbool_t_val, svuint64_t_val); + svcvt_f32_z(svbool_t_val, svfloat16_t_val); + svcvt_f32_z(svbool_t_val, svfloat64_t_val); + svcvt_f32_z(svbool_t_val, svint32_t_val); + svcvt_f32_z(svbool_t_val, svint64_t_val); + svcvt_f32_z(svbool_t_val, svuint32_t_val); + svcvt_f32_z(svbool_t_val, svuint64_t_val); + svcvt_f64_f16_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_f32_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_s32_m(svfloat64_t_val, svbool_t_val, svint32_t_val); + svcvt_f64_s32_x(svbool_t_val, svint32_t_val); + svcvt_f64_s32_z(svbool_t_val, svint32_t_val); + svcvt_f64_s64_m(svfloat64_t_val, svbool_t_val, svint64_t_val); + svcvt_f64_s64_x(svbool_t_val, svint64_t_val); + svcvt_f64_s64_z(svbool_t_val, svint64_t_val); + svcvt_f64_u32_m(svfloat64_t_val, svbool_t_val, svuint32_t_val); + svcvt_f64_u32_x(svbool_t_val, svuint32_t_val); + svcvt_f64_u32_z(svbool_t_val, svuint32_t_val); + svcvt_f64_u64_m(svfloat64_t_val, svbool_t_val, svuint64_t_val); + svcvt_f64_u64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_u64_z(svbool_t_val, svuint64_t_val); + svcvt_f64_x(svbool_t_val, svfloat16_t_val); + svcvt_f64_x(svbool_t_val, svfloat32_t_val); + svcvt_f64_x(svbool_t_val, svint32_t_val); + svcvt_f64_x(svbool_t_val, svint64_t_val); + svcvt_f64_x(svbool_t_val, svuint32_t_val); + svcvt_f64_x(svbool_t_val, svuint64_t_val); + svcvt_f64_z(svbool_t_val, svfloat16_t_val); + svcvt_f64_z(svbool_t_val, svfloat32_t_val); + svcvt_f64_z(svbool_t_val, svint32_t_val); + svcvt_f64_z(svbool_t_val, svint64_t_val); + svcvt_f64_z(svbool_t_val, svuint32_t_val); + svcvt_f64_z(svbool_t_val, svuint64_t_val); + svcvt_s16_f16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s16_m(svint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s16_x(svbool_t_val, svfloat16_t_val); + svcvt_s16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_f32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_f64_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s32_m(svint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s32_x(svbool_t_val, svfloat16_t_val); + svcvt_s32_x(svbool_t_val, svfloat32_t_val); + svcvt_s32_x(svbool_t_val, svfloat64_t_val); + svcvt_s32_z(svbool_t_val, svfloat16_t_val); + svcvt_s32_z(svbool_t_val, svfloat32_t_val); + svcvt_s32_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_f16_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_f32_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_f64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_s64_m(svint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_s64_x(svbool_t_val, svfloat16_t_val); + svcvt_s64_x(svbool_t_val, svfloat32_t_val); + svcvt_s64_x(svbool_t_val, svfloat64_t_val); + svcvt_s64_z(svbool_t_val, svfloat16_t_val); + svcvt_s64_z(svbool_t_val, svfloat32_t_val); + svcvt_s64_z(svbool_t_val, svfloat64_t_val); + svcvt_u16_f16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u16_m(svuint16_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u16_x(svbool_t_val, svfloat16_t_val); + svcvt_u16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_f32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_f64_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u32_m(svuint32_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u32_x(svbool_t_val, svfloat16_t_val); + svcvt_u32_x(svbool_t_val, svfloat32_t_val); + svcvt_u32_x(svbool_t_val, svfloat64_t_val); + svcvt_u32_z(svbool_t_val, svfloat16_t_val); + svcvt_u32_z(svbool_t_val, svfloat32_t_val); + svcvt_u32_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_f16_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_f16_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_f32_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_f32_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_f64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_f64_z(svbool_t_val, svfloat64_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat16_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat32_t_val); + svcvt_u64_m(svuint64_t_val, svbool_t_val, svfloat64_t_val); + svcvt_u64_x(svbool_t_val, svfloat16_t_val); + svcvt_u64_x(svbool_t_val, svfloat32_t_val); + svcvt_u64_x(svbool_t_val, svfloat64_t_val); + svcvt_u64_z(svbool_t_val, svfloat16_t_val); + svcvt_u64_z(svbool_t_val, svfloat32_t_val); + svcvt_u64_z(svbool_t_val, svfloat64_t_val); + svdiv_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_x(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_x(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdiv_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdiv_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdiv_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdiv_z(svbool_t_val, svint32_t_val, int32_t_val); + svdiv_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdiv_z(svbool_t_val, svint64_t_val, int64_t_val); + svdiv_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdiv_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdiv_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_x(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_x(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svdivr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svdivr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svdivr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svdivr_z(svbool_t_val, svint32_t_val, int32_t_val); + svdivr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svdivr_z(svbool_t_val, svint64_t_val, int64_t_val); + svdivr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svdivr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svdivr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svdot(svint32_t_val, svint8_t_val, int8_t_val); + svdot(svint32_t_val, svint8_t_val, svint8_t_val); + svdot(svint64_t_val, svint16_t_val, int16_t_val); + svdot(svint64_t_val, svint16_t_val, svint16_t_val); + svdot(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdot(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_lane(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_lane_s32(svint32_t_val, svint8_t_val, svint8_t_val, 1); + svdot_lane_s64(svint64_t_val, svint16_t_val, svint16_t_val, 1); + svdot_lane_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val, 1); + svdot_lane_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val, 1); + svdot_n_s32(svint32_t_val, svint8_t_val, int8_t_val); + svdot_n_s64(svint64_t_val, svint16_t_val, int16_t_val); + svdot_n_u32(svuint32_t_val, svuint8_t_val, uint8_t_val); + svdot_n_u64(svuint64_t_val, svuint16_t_val, uint16_t_val); + svdot_s32(svint32_t_val, svint8_t_val, svint8_t_val); + svdot_s64(svint64_t_val, svint16_t_val, svint16_t_val); + svdot_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svdot_u64(svuint64_t_val, svuint16_t_val, svuint16_t_val); + svdup_b8(bool_val); + svdup_b16(bool_val); + svdup_b32(bool_val); + svdup_b64(bool_val); + svdup_bf16(bfloat16_t_val); + svdup_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_f16(float16_t_val); + svdup_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_f16_x(svbool_t_val, float16_t_val); + svdup_f16_z(svbool_t_val, float16_t_val); + svdup_f32(float32_t_val); + svdup_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_f32_x(svbool_t_val, float32_t_val); + svdup_f32_z(svbool_t_val, float32_t_val); + svdup_f64(float64_t_val); + svdup_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_f64_x(svbool_t_val, float64_t_val); + svdup_f64_z(svbool_t_val, float64_t_val); + svdup_lane(svbfloat16_t_val, uint16_t_val); + svdup_lane(svfloat16_t_val, uint16_t_val); + svdup_lane(svfloat32_t_val, uint32_t_val); + svdup_lane(svfloat64_t_val, uint64_t_val); + svdup_lane(svint8_t_val, uint8_t_val); + svdup_lane(svint16_t_val, uint16_t_val); + svdup_lane(svint32_t_val, uint32_t_val); + svdup_lane(svint64_t_val, uint64_t_val); + svdup_lane(svuint8_t_val, uint8_t_val); + svdup_lane(svuint16_t_val, uint16_t_val); + svdup_lane(svuint32_t_val, uint32_t_val); + svdup_lane(svuint64_t_val, uint64_t_val); + svdup_lane_bf16(svbfloat16_t_val, uint16_t_val); + svdup_lane_f16(svfloat16_t_val, uint16_t_val); + svdup_lane_f32(svfloat32_t_val, uint32_t_val); + svdup_lane_f64(svfloat64_t_val, uint64_t_val); + svdup_lane_s8(svint8_t_val, uint8_t_val); + svdup_lane_s16(svint16_t_val, uint16_t_val); + svdup_lane_s32(svint32_t_val, uint32_t_val); + svdup_lane_s64(svint64_t_val, uint64_t_val); + svdup_lane_u8(svuint8_t_val, uint8_t_val); + svdup_lane_u16(svuint16_t_val, uint16_t_val); + svdup_lane_u32(svuint32_t_val, uint32_t_val); + svdup_lane_u64(svuint64_t_val, uint64_t_val); + svdup_n_b8(bool_val); + svdup_n_b16(bool_val); + svdup_n_b32(bool_val); + svdup_n_b64(bool_val); + svdup_n_bf16(bfloat16_t_val); + svdup_n_bf16_m(svbfloat16_t_val, svbool_t_val, bfloat16_t_val); + svdup_n_bf16_x(svbool_t_val, bfloat16_t_val); + svdup_n_bf16_z(svbool_t_val, bfloat16_t_val); + svdup_n_f16(float16_t_val); + svdup_n_f16_m(svfloat16_t_val, svbool_t_val, float16_t_val); + svdup_n_f16_x(svbool_t_val, float16_t_val); + svdup_n_f16_z(svbool_t_val, float16_t_val); + svdup_n_f32(float32_t_val); + svdup_n_f32_m(svfloat32_t_val, svbool_t_val, float32_t_val); + svdup_n_f32_x(svbool_t_val, float32_t_val); + svdup_n_f32_z(svbool_t_val, float32_t_val); + svdup_n_f64(float64_t_val); + svdup_n_f64_m(svfloat64_t_val, svbool_t_val, float64_t_val); + svdup_n_f64_x(svbool_t_val, float64_t_val); + svdup_n_f64_z(svbool_t_val, float64_t_val); + svdup_n_s8(int8_t_val); + svdup_n_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_n_s8_x(svbool_t_val, int8_t_val); + svdup_n_s8_z(svbool_t_val, int8_t_val); + svdup_n_s16(int16_t_val); + svdup_n_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_n_s16_x(svbool_t_val, int16_t_val); + svdup_n_s16_z(svbool_t_val, int16_t_val); + svdup_n_s32(int32_t_val); + svdup_n_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_n_s32_x(svbool_t_val, int32_t_val); + svdup_n_s32_z(svbool_t_val, int32_t_val); + svdup_n_s64(int64_t_val); + svdup_n_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_n_s64_x(svbool_t_val, int64_t_val); + svdup_n_s64_z(svbool_t_val, int64_t_val); + svdup_n_u8(uint8_t_val); + svdup_n_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_n_u8_x(svbool_t_val, uint8_t_val); + svdup_n_u8_z(svbool_t_val, uint8_t_val); + svdup_n_u16(uint16_t_val); + svdup_n_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_n_u16_x(svbool_t_val, uint16_t_val); + svdup_n_u16_z(svbool_t_val, uint16_t_val); + svdup_n_u32(uint32_t_val); + svdup_n_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_n_u32_x(svbool_t_val, uint32_t_val); + svdup_n_u32_z(svbool_t_val, uint32_t_val); + svdup_n_u64(uint64_t_val); + svdup_n_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_n_u64_x(svbool_t_val, uint64_t_val); + svdup_n_u64_z(svbool_t_val, uint64_t_val); + svdup_s8(int8_t_val); + svdup_s8_m(svint8_t_val, svbool_t_val, int8_t_val); + svdup_s8_x(svbool_t_val, int8_t_val); + svdup_s8_z(svbool_t_val, int8_t_val); + svdup_s16(int16_t_val); + svdup_s16_m(svint16_t_val, svbool_t_val, int16_t_val); + svdup_s16_x(svbool_t_val, int16_t_val); + svdup_s16_z(svbool_t_val, int16_t_val); + svdup_s32(int32_t_val); + svdup_s32_m(svint32_t_val, svbool_t_val, int32_t_val); + svdup_s32_x(svbool_t_val, int32_t_val); + svdup_s32_z(svbool_t_val, int32_t_val); + svdup_s64(int64_t_val); + svdup_s64_m(svint64_t_val, svbool_t_val, int64_t_val); + svdup_s64_x(svbool_t_val, int64_t_val); + svdup_s64_z(svbool_t_val, int64_t_val); + svdup_u8(uint8_t_val); + svdup_u8_m(svuint8_t_val, svbool_t_val, uint8_t_val); + svdup_u8_x(svbool_t_val, uint8_t_val); + svdup_u8_z(svbool_t_val, uint8_t_val); + svdup_u16(uint16_t_val); + svdup_u16_m(svuint16_t_val, svbool_t_val, uint16_t_val); + svdup_u16_x(svbool_t_val, uint16_t_val); + svdup_u16_z(svbool_t_val, uint16_t_val); + svdup_u32(uint32_t_val); + svdup_u32_m(svuint32_t_val, svbool_t_val, uint32_t_val); + svdup_u32_x(svbool_t_val, uint32_t_val); + svdup_u32_z(svbool_t_val, uint32_t_val); + svdup_u64(uint64_t_val); + svdup_u64_m(svuint64_t_val, svbool_t_val, uint64_t_val); + svdup_u64_x(svbool_t_val, uint64_t_val); + svdup_u64_z(svbool_t_val, uint64_t_val); + svdupq_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_b64(bool_val, bool_val); + svdupq_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_f64(float64_t_val, float64_t_val); + svdupq_lane(svbfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat16_t_val, uint64_t_val); + svdupq_lane(svfloat32_t_val, uint64_t_val); + svdupq_lane(svfloat64_t_val, uint64_t_val); + svdupq_lane(svint8_t_val, uint64_t_val); + svdupq_lane(svint16_t_val, uint64_t_val); + svdupq_lane(svint32_t_val, uint64_t_val); + svdupq_lane(svint64_t_val, uint64_t_val); + svdupq_lane(svuint8_t_val, uint64_t_val); + svdupq_lane(svuint16_t_val, uint64_t_val); + svdupq_lane(svuint32_t_val, uint64_t_val); + svdupq_lane(svuint64_t_val, uint64_t_val); + svdupq_lane_bf16(svbfloat16_t_val, uint64_t_val); + svdupq_lane_f16(svfloat16_t_val, uint64_t_val); + svdupq_lane_f32(svfloat32_t_val, uint64_t_val); + svdupq_lane_f64(svfloat64_t_val, uint64_t_val); + svdupq_lane_s8(svint8_t_val, uint64_t_val); + svdupq_lane_s16(svint16_t_val, uint64_t_val); + svdupq_lane_s32(svint32_t_val, uint64_t_val); + svdupq_lane_s64(svint64_t_val, uint64_t_val); + svdupq_lane_u8(svuint8_t_val, uint64_t_val); + svdupq_lane_u16(svuint16_t_val, uint64_t_val); + svdupq_lane_u32(svuint32_t_val, uint64_t_val); + svdupq_lane_u64(svuint64_t_val, uint64_t_val); + svdupq_n_b8(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b16(bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val, bool_val); + svdupq_n_b32(bool_val, bool_val, bool_val, bool_val); + svdupq_n_b64(bool_val, bool_val); + svdupq_n_bf16(bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val, bfloat16_t_val); + svdupq_n_f16(float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val, float16_t_val); + svdupq_n_f32(float32_t_val, float32_t_val, float32_t_val, float32_t_val); + svdupq_n_f64(float64_t_val, float64_t_val); + svdupq_n_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_n_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_n_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_n_s64(int64_t_val, int64_t_val); + svdupq_n_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_n_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_n_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_n_u64(uint64_t_val, uint64_t_val); + svdupq_s8(int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val, int8_t_val); + svdupq_s16(int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val, int16_t_val); + svdupq_s32(int32_t_val, int32_t_val, int32_t_val, int32_t_val); + svdupq_s64(int64_t_val, int64_t_val); + svdupq_u8(uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val, uint8_t_val); + svdupq_u16(uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val, uint16_t_val); + svdupq_u32(uint32_t_val, uint32_t_val, uint32_t_val, uint32_t_val); + svdupq_u64(uint64_t_val, uint64_t_val); + sveor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svint8_t_val, int8_t_val); + sveor_x(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_x(svbool_t_val, svint16_t_val, int16_t_val); + sveor_x(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_x(svbool_t_val, svint32_t_val, int32_t_val); + sveor_x(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_x(svbool_t_val, svint64_t_val, int64_t_val); + sveor_x(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_x(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_x(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_x(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_x(svbool_t_val, svuint64_t_val, uint64_t_val); + sveor_z(svbool_t_val, svbool_t_val, svbool_t_val); + sveor_z(svbool_t_val, svint8_t_val, int8_t_val); + sveor_z(svbool_t_val, svint8_t_val, svint8_t_val); + sveor_z(svbool_t_val, svint16_t_val, int16_t_val); + sveor_z(svbool_t_val, svint16_t_val, svint16_t_val); + sveor_z(svbool_t_val, svint32_t_val, int32_t_val); + sveor_z(svbool_t_val, svint32_t_val, svint32_t_val); + sveor_z(svbool_t_val, svint64_t_val, int64_t_val); + sveor_z(svbool_t_val, svint64_t_val, svint64_t_val); + sveor_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + sveor_z(svbool_t_val, svuint8_t_val, uint8_t_val); + sveor_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + sveor_z(svbool_t_val, svuint16_t_val, uint16_t_val); + sveor_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + sveor_z(svbool_t_val, svuint32_t_val, uint32_t_val); + sveor_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + sveor_z(svbool_t_val, svuint64_t_val, uint64_t_val); + sveorv(svbool_t_val, svint8_t_val); + sveorv(svbool_t_val, svint16_t_val); + sveorv(svbool_t_val, svint32_t_val); + sveorv(svbool_t_val, svint64_t_val); + sveorv(svbool_t_val, svuint8_t_val); + sveorv(svbool_t_val, svuint16_t_val); + sveorv(svbool_t_val, svuint32_t_val); + sveorv(svbool_t_val, svuint64_t_val); + sveorv_s8(svbool_t_val, svint8_t_val); + sveorv_s16(svbool_t_val, svint16_t_val); + sveorv_s32(svbool_t_val, svint32_t_val); + sveorv_s64(svbool_t_val, svint64_t_val); + sveorv_u8(svbool_t_val, svuint8_t_val); + sveorv_u16(svbool_t_val, svuint16_t_val); + sveorv_u32(svbool_t_val, svuint32_t_val); + sveorv_u64(svbool_t_val, svuint64_t_val); + svext(svbfloat16_t_val, svbfloat16_t_val, 2); + svext(svfloat16_t_val, svfloat16_t_val, 2); + svext(svfloat32_t_val, svfloat32_t_val, 2); + svext(svfloat64_t_val, svfloat64_t_val, 2); + svext(svint8_t_val, svint8_t_val, 2); + svext(svint16_t_val, svint16_t_val, 2); + svext(svint32_t_val, svint32_t_val, 2); + svext(svint64_t_val, svint64_t_val, 2); + svext(svuint8_t_val, svuint8_t_val, 2); + svext(svuint16_t_val, svuint16_t_val, 2); + svext(svuint32_t_val, svuint32_t_val, 2); + svext(svuint64_t_val, svuint64_t_val, 2); + svext_bf16(svbfloat16_t_val, svbfloat16_t_val, 2); + svext_f16(svfloat16_t_val, svfloat16_t_val, 2); + svext_f32(svfloat32_t_val, svfloat32_t_val, 2); + svext_f64(svfloat64_t_val, svfloat64_t_val, 2); + svext_s8(svint8_t_val, svint8_t_val, 2); + svext_s16(svint16_t_val, svint16_t_val, 2); + svext_s32(svint32_t_val, svint32_t_val, 2); + svext_s64(svint64_t_val, svint64_t_val, 2); + svext_u8(svuint8_t_val, svuint8_t_val, 2); + svext_u16(svuint16_t_val, svuint16_t_val, 2); + svext_u32(svuint32_t_val, svuint32_t_val, 2); + svext_u64(svuint64_t_val, svuint64_t_val, 2); + svextb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svextb_s16_x(svbool_t_val, svint16_t_val); + svextb_s16_z(svbool_t_val, svint16_t_val); + svextb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svextb_s32_x(svbool_t_val, svint32_t_val); + svextb_s32_z(svbool_t_val, svint32_t_val); + svextb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextb_s64_x(svbool_t_val, svint64_t_val); + svextb_s64_z(svbool_t_val, svint64_t_val); + svextb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svextb_u16_x(svbool_t_val, svuint16_t_val); + svextb_u16_z(svbool_t_val, svuint16_t_val); + svextb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svextb_u32_x(svbool_t_val, svuint32_t_val); + svextb_u32_z(svbool_t_val, svuint32_t_val); + svextb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextb_u64_x(svbool_t_val, svuint64_t_val); + svextb_u64_z(svbool_t_val, svuint64_t_val); + svextb_x(svbool_t_val, svint16_t_val); + svextb_x(svbool_t_val, svint32_t_val); + svextb_x(svbool_t_val, svint64_t_val); + svextb_x(svbool_t_val, svuint16_t_val); + svextb_x(svbool_t_val, svuint32_t_val); + svextb_x(svbool_t_val, svuint64_t_val); + svextb_z(svbool_t_val, svint16_t_val); + svextb_z(svbool_t_val, svint32_t_val); + svextb_z(svbool_t_val, svint64_t_val); + svextb_z(svbool_t_val, svuint16_t_val); + svextb_z(svbool_t_val, svuint32_t_val); + svextb_z(svbool_t_val, svuint64_t_val); + svexth_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svexth_s32_x(svbool_t_val, svint32_t_val); + svexth_s32_z(svbool_t_val, svint32_t_val); + svexth_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svexth_s64_x(svbool_t_val, svint64_t_val); + svexth_s64_z(svbool_t_val, svint64_t_val); + svexth_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svexth_u32_x(svbool_t_val, svuint32_t_val); + svexth_u32_z(svbool_t_val, svuint32_t_val); + svexth_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svexth_u64_x(svbool_t_val, svuint64_t_val); + svexth_u64_z(svbool_t_val, svuint64_t_val); + svexth_x(svbool_t_val, svint32_t_val); + svexth_x(svbool_t_val, svint64_t_val); + svexth_x(svbool_t_val, svuint32_t_val); + svexth_x(svbool_t_val, svuint64_t_val); + svexth_z(svbool_t_val, svint32_t_val); + svexth_z(svbool_t_val, svint64_t_val); + svexth_z(svbool_t_val, svuint32_t_val); + svexth_z(svbool_t_val, svuint64_t_val); + svextw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svextw_s64_x(svbool_t_val, svint64_t_val); + svextw_s64_z(svbool_t_val, svint64_t_val); + svextw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svextw_u64_x(svbool_t_val, svuint64_t_val); + svextw_u64_z(svbool_t_val, svuint64_t_val); + svextw_x(svbool_t_val, svint64_t_val); + svextw_x(svbool_t_val, svuint64_t_val); + svextw_z(svbool_t_val, svint64_t_val); + svextw_z(svbool_t_val, svuint64_t_val); + svget2(svbfloat16x2_t_val, 1); + svget2(svfloat16x2_t_val, 1); + svget2(svfloat32x2_t_val, 1); + svget2(svfloat64x2_t_val, 1); + svget2(svint8x2_t_val, 1); + svget2(svint16x2_t_val, 1); + svget2(svint32x2_t_val, 1); + svget2(svint64x2_t_val, 1); + svget2(svmfloat8x2_t_val, 1); + svget2(svuint8x2_t_val, 1); + svget2(svuint16x2_t_val, 1); + svget2(svuint32x2_t_val, 1); + svget2(svuint64x2_t_val, 1); + svget2_bf16(svbfloat16x2_t_val, 1); + svget2_f16(svfloat16x2_t_val, 1); + svget2_f32(svfloat32x2_t_val, 1); + svget2_f64(svfloat64x2_t_val, 1); + svget2_mf8(svmfloat8x2_t_val, 1); + svget2_s8(svint8x2_t_val, 1); + svget2_s16(svint16x2_t_val, 1); + svget2_s32(svint32x2_t_val, 1); + svget2_s64(svint64x2_t_val, 1); + svget2_u8(svuint8x2_t_val, 1); + svget2_u16(svuint16x2_t_val, 1); + svget2_u32(svuint32x2_t_val, 1); + svget2_u64(svuint64x2_t_val, 1); + svget3(svbfloat16x3_t_val, 2); + svget3(svfloat16x3_t_val, 2); + svget3(svfloat32x3_t_val, 2); + svget3(svfloat64x3_t_val, 2); + svget3(svint8x3_t_val, 2); + svget3(svint16x3_t_val, 2); + svget3(svint32x3_t_val, 2); + svget3(svint64x3_t_val, 2); + svget3(svmfloat8x3_t_val, 2); + svget3(svuint8x3_t_val, 2); + svget3(svuint16x3_t_val, 2); + svget3(svuint32x3_t_val, 2); + svget3(svuint64x3_t_val, 2); + svget3_bf16(svbfloat16x3_t_val, 2); + svget3_f16(svfloat16x3_t_val, 2); + svget3_f32(svfloat32x3_t_val, 2); + svget3_f64(svfloat64x3_t_val, 2); + svget3_mf8(svmfloat8x3_t_val, 2); + svget3_s8(svint8x3_t_val, 2); + svget3_s16(svint16x3_t_val, 2); + svget3_s32(svint32x3_t_val, 2); + svget3_s64(svint64x3_t_val, 2); + svget3_u8(svuint8x3_t_val, 2); + svget3_u16(svuint16x3_t_val, 2); + svget3_u32(svuint32x3_t_val, 2); + svget3_u64(svuint64x3_t_val, 2); + svget4(svbfloat16x4_t_val, 2); + svget4(svfloat16x4_t_val, 2); + svget4(svfloat32x4_t_val, 2); + svget4(svfloat64x4_t_val, 2); + svget4(svint8x4_t_val, 2); + svget4(svint16x4_t_val, 2); + svget4(svint32x4_t_val, 2); + svget4(svint64x4_t_val, 2); + svget4(svmfloat8x4_t_val, 2); + svget4(svuint8x4_t_val, 2); + svget4(svuint16x4_t_val, 2); + svget4(svuint32x4_t_val, 2); + svget4(svuint64x4_t_val, 2); + svget4_bf16(svbfloat16x4_t_val, 2); + svget4_f16(svfloat16x4_t_val, 2); + svget4_f32(svfloat32x4_t_val, 2); + svget4_f64(svfloat64x4_t_val, 2); + svget4_mf8(svmfloat8x4_t_val, 2); + svget4_s8(svint8x4_t_val, 2); + svget4_s16(svint16x4_t_val, 2); + svget4_s32(svint32x4_t_val, 2); + svget4_s64(svint64x4_t_val, 2); + svget4_u8(svuint8x4_t_val, 2); + svget4_u16(svuint16x4_t_val, 2); + svget4_u32(svuint32x4_t_val, 2); + svget4_u64(svuint64x4_t_val, 2); + svindex_s8(int8_t_val, int8_t_val); + svindex_s16(int16_t_val, int16_t_val); + svindex_s32(int32_t_val, int32_t_val); + svindex_s64(int64_t_val, int64_t_val); + svindex_u8(uint8_t_val, uint8_t_val); + svindex_u16(uint16_t_val, uint16_t_val); + svindex_u32(uint32_t_val, uint32_t_val); + svindex_u64(uint64_t_val, uint64_t_val); + svinsr(svbfloat16_t_val, bfloat16_t_val); + svinsr(svfloat16_t_val, float16_t_val); + svinsr(svfloat32_t_val, float32_t_val); + svinsr(svfloat64_t_val, float64_t_val); + svinsr(svint8_t_val, int8_t_val); + svinsr(svint16_t_val, int16_t_val); + svinsr(svint32_t_val, int32_t_val); + svinsr(svint64_t_val, int64_t_val); + svinsr(svuint8_t_val, uint8_t_val); + svinsr(svuint16_t_val, uint16_t_val); + svinsr(svuint32_t_val, uint32_t_val); + svinsr(svuint64_t_val, uint64_t_val); + svinsr_n_bf16(svbfloat16_t_val, bfloat16_t_val); + svinsr_n_f16(svfloat16_t_val, float16_t_val); + svinsr_n_f32(svfloat32_t_val, float32_t_val); + svinsr_n_f64(svfloat64_t_val, float64_t_val); + svinsr_n_s8(svint8_t_val, int8_t_val); + svinsr_n_s16(svint16_t_val, int16_t_val); + svinsr_n_s32(svint32_t_val, int32_t_val); + svinsr_n_s64(svint64_t_val, int64_t_val); + svinsr_n_u8(svuint8_t_val, uint8_t_val); + svinsr_n_u16(svuint16_t_val, uint16_t_val); + svinsr_n_u32(svuint32_t_val, uint32_t_val); + svinsr_n_u64(svuint64_t_val, uint64_t_val); + svlasta(svbool_t_val, svbfloat16_t_val); + svlasta(svbool_t_val, svfloat16_t_val); + svlasta(svbool_t_val, svfloat32_t_val); + svlasta(svbool_t_val, svfloat64_t_val); + svlasta(svbool_t_val, svint8_t_val); + svlasta(svbool_t_val, svint16_t_val); + svlasta(svbool_t_val, svint32_t_val); + svlasta(svbool_t_val, svint64_t_val); + svlasta(svbool_t_val, svuint8_t_val); + svlasta(svbool_t_val, svuint16_t_val); + svlasta(svbool_t_val, svuint32_t_val); + svlasta(svbool_t_val, svuint64_t_val); + svlasta_bf16(svbool_t_val, svbfloat16_t_val); + svlasta_f16(svbool_t_val, svfloat16_t_val); + svlasta_f32(svbool_t_val, svfloat32_t_val); + svlasta_f64(svbool_t_val, svfloat64_t_val); + svlasta_s8(svbool_t_val, svint8_t_val); + svlasta_s16(svbool_t_val, svint16_t_val); + svlasta_s32(svbool_t_val, svint32_t_val); + svlasta_s64(svbool_t_val, svint64_t_val); + svlasta_u8(svbool_t_val, svuint8_t_val); + svlasta_u16(svbool_t_val, svuint16_t_val); + svlasta_u32(svbool_t_val, svuint32_t_val); + svlasta_u64(svbool_t_val, svuint64_t_val); + svlastb(svbool_t_val, svbfloat16_t_val); + svlastb(svbool_t_val, svfloat16_t_val); + svlastb(svbool_t_val, svfloat32_t_val); + svlastb(svbool_t_val, svfloat64_t_val); + svlastb(svbool_t_val, svint8_t_val); + svlastb(svbool_t_val, svint16_t_val); + svlastb(svbool_t_val, svint32_t_val); + svlastb(svbool_t_val, svint64_t_val); + svlastb(svbool_t_val, svuint8_t_val); + svlastb(svbool_t_val, svuint16_t_val); + svlastb(svbool_t_val, svuint32_t_val); + svlastb(svbool_t_val, svuint64_t_val); + svlastb_bf16(svbool_t_val, svbfloat16_t_val); + svlastb_f16(svbool_t_val, svfloat16_t_val); + svlastb_f32(svbool_t_val, svfloat32_t_val); + svlastb_f64(svbool_t_val, svfloat64_t_val); + svlastb_s8(svbool_t_val, svint8_t_val); + svlastb_s16(svbool_t_val, svint16_t_val); + svlastb_s32(svbool_t_val, svint32_t_val); + svlastb_s64(svbool_t_val, svint64_t_val); + svlastb_u8(svbool_t_val, svuint8_t_val); + svlastb_u16(svbool_t_val, svuint16_t_val); + svlastb_u32(svbool_t_val, svuint32_t_val); + svlastb_u64(svbool_t_val, svuint64_t_val); + svld1(svbool_t_val, bfloat16_t_ptr_val); + svld1(svbool_t_val, float16_t_ptr_val); + svld1(svbool_t_val, float32_t_ptr_val); + svld1(svbool_t_val, float64_t_ptr_val); + svld1(svbool_t_val, int8_t_ptr_val); + svld1(svbool_t_val, int16_t_ptr_val); + svld1(svbool_t_val, int32_t_ptr_val); + svld1(svbool_t_val, int64_t_ptr_val); + svld1(svbool_t_val, mfloat8_t_ptr_val); + svld1(svbool_t_val, uint8_t_ptr_val); + svld1(svbool_t_val, uint16_t_ptr_val); + svld1(svbool_t_val, uint32_t_ptr_val); + svld1(svbool_t_val, uint64_t_ptr_val); + svld1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1_f16(svbool_t_val, float16_t_ptr_val); + svld1_f32(svbool_t_val, float32_t_ptr_val); + svld1_f64(svbool_t_val, float64_t_ptr_val); + svld1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1_s8(svbool_t_val, int8_t_ptr_val); + svld1_s16(svbool_t_val, int16_t_ptr_val); + svld1_s32(svbool_t_val, int32_t_ptr_val); + svld1_s64(svbool_t_val, int64_t_ptr_val); + svld1_u8(svbool_t_val, uint8_t_ptr_val); + svld1_u16(svbool_t_val, uint16_t_ptr_val); + svld1_u32(svbool_t_val, uint32_t_ptr_val); + svld1_u64(svbool_t_val, uint64_t_ptr_val); + svld1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1rq(svbool_t_val, bfloat16_t_ptr_val); + svld1rq(svbool_t_val, float16_t_ptr_val); + svld1rq(svbool_t_val, float32_t_ptr_val); + svld1rq(svbool_t_val, float64_t_ptr_val); + svld1rq(svbool_t_val, int8_t_ptr_val); + svld1rq(svbool_t_val, int16_t_ptr_val); + svld1rq(svbool_t_val, int32_t_ptr_val); + svld1rq(svbool_t_val, int64_t_ptr_val); + svld1rq(svbool_t_val, mfloat8_t_ptr_val); + svld1rq(svbool_t_val, uint8_t_ptr_val); + svld1rq(svbool_t_val, uint16_t_ptr_val); + svld1rq(svbool_t_val, uint32_t_ptr_val); + svld1rq(svbool_t_val, uint64_t_ptr_val); + svld1rq_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1rq_f16(svbool_t_val, float16_t_ptr_val); + svld1rq_f32(svbool_t_val, float32_t_ptr_val); + svld1rq_f64(svbool_t_val, float64_t_ptr_val); + svld1rq_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1rq_s8(svbool_t_val, int8_t_ptr_val); + svld1rq_s16(svbool_t_val, int16_t_ptr_val); + svld1rq_s32(svbool_t_val, int32_t_ptr_val); + svld1rq_s64(svbool_t_val, int64_t_ptr_val); + svld1rq_u8(svbool_t_val, uint8_t_ptr_val); + svld1rq_u16(svbool_t_val, uint16_t_ptr_val); + svld1rq_u32(svbool_t_val, uint32_t_ptr_val); + svld1rq_u64(svbool_t_val, uint64_t_ptr_val); + svld1sb_s16(svbool_t_val, int8_t_ptr_val); + svld1sb_s32(svbool_t_val, int8_t_ptr_val); + svld1sb_s64(svbool_t_val, int8_t_ptr_val); + svld1sb_u16(svbool_t_val, int8_t_ptr_val); + svld1sb_u32(svbool_t_val, int8_t_ptr_val); + svld1sb_u64(svbool_t_val, int8_t_ptr_val); + svld1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld1sh_s32(svbool_t_val, int16_t_ptr_val); + svld1sh_s64(svbool_t_val, int16_t_ptr_val); + svld1sh_u32(svbool_t_val, int16_t_ptr_val); + svld1sh_u64(svbool_t_val, int16_t_ptr_val); + svld1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld1sw_s64(svbool_t_val, int32_t_ptr_val); + svld1sw_u64(svbool_t_val, int32_t_ptr_val); + svld1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1ub_s16(svbool_t_val, uint8_t_ptr_val); + svld1ub_s32(svbool_t_val, uint8_t_ptr_val); + svld1ub_s64(svbool_t_val, uint8_t_ptr_val); + svld1ub_u16(svbool_t_val, uint8_t_ptr_val); + svld1ub_u32(svbool_t_val, uint8_t_ptr_val); + svld1ub_u64(svbool_t_val, uint8_t_ptr_val); + svld1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld1uh_s32(svbool_t_val, uint16_t_ptr_val); + svld1uh_s64(svbool_t_val, uint16_t_ptr_val); + svld1uh_u32(svbool_t_val, uint16_t_ptr_val); + svld1uh_u64(svbool_t_val, uint16_t_ptr_val); + svld1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld1uw_s64(svbool_t_val, uint32_t_ptr_val); + svld1uw_u64(svbool_t_val, uint32_t_ptr_val); + svld1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2(svbool_t_val, bfloat16_t_ptr_val); + svld2(svbool_t_val, float16_t_ptr_val); + svld2(svbool_t_val, float32_t_ptr_val); + svld2(svbool_t_val, float64_t_ptr_val); + svld2(svbool_t_val, int8_t_ptr_val); + svld2(svbool_t_val, int16_t_ptr_val); + svld2(svbool_t_val, int32_t_ptr_val); + svld2(svbool_t_val, int64_t_ptr_val); + svld2(svbool_t_val, mfloat8_t_ptr_val); + svld2(svbool_t_val, uint8_t_ptr_val); + svld2(svbool_t_val, uint16_t_ptr_val); + svld2(svbool_t_val, uint32_t_ptr_val); + svld2(svbool_t_val, uint64_t_ptr_val); + svld2_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld2_f16(svbool_t_val, float16_t_ptr_val); + svld2_f32(svbool_t_val, float32_t_ptr_val); + svld2_f64(svbool_t_val, float64_t_ptr_val); + svld2_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld2_s8(svbool_t_val, int8_t_ptr_val); + svld2_s16(svbool_t_val, int16_t_ptr_val); + svld2_s32(svbool_t_val, int32_t_ptr_val); + svld2_s64(svbool_t_val, int64_t_ptr_val); + svld2_u8(svbool_t_val, uint8_t_ptr_val); + svld2_u16(svbool_t_val, uint16_t_ptr_val); + svld2_u32(svbool_t_val, uint32_t_ptr_val); + svld2_u64(svbool_t_val, uint64_t_ptr_val); + svld2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3(svbool_t_val, bfloat16_t_ptr_val); + svld3(svbool_t_val, float16_t_ptr_val); + svld3(svbool_t_val, float32_t_ptr_val); + svld3(svbool_t_val, float64_t_ptr_val); + svld3(svbool_t_val, int8_t_ptr_val); + svld3(svbool_t_val, int16_t_ptr_val); + svld3(svbool_t_val, int32_t_ptr_val); + svld3(svbool_t_val, int64_t_ptr_val); + svld3(svbool_t_val, mfloat8_t_ptr_val); + svld3(svbool_t_val, uint8_t_ptr_val); + svld3(svbool_t_val, uint16_t_ptr_val); + svld3(svbool_t_val, uint32_t_ptr_val); + svld3(svbool_t_val, uint64_t_ptr_val); + svld3_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld3_f16(svbool_t_val, float16_t_ptr_val); + svld3_f32(svbool_t_val, float32_t_ptr_val); + svld3_f64(svbool_t_val, float64_t_ptr_val); + svld3_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld3_s8(svbool_t_val, int8_t_ptr_val); + svld3_s16(svbool_t_val, int16_t_ptr_val); + svld3_s32(svbool_t_val, int32_t_ptr_val); + svld3_s64(svbool_t_val, int64_t_ptr_val); + svld3_u8(svbool_t_val, uint8_t_ptr_val); + svld3_u16(svbool_t_val, uint16_t_ptr_val); + svld3_u32(svbool_t_val, uint32_t_ptr_val); + svld3_u64(svbool_t_val, uint64_t_ptr_val); + svld3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4(svbool_t_val, bfloat16_t_ptr_val); + svld4(svbool_t_val, float16_t_ptr_val); + svld4(svbool_t_val, float32_t_ptr_val); + svld4(svbool_t_val, float64_t_ptr_val); + svld4(svbool_t_val, int8_t_ptr_val); + svld4(svbool_t_val, int16_t_ptr_val); + svld4(svbool_t_val, int32_t_ptr_val); + svld4(svbool_t_val, int64_t_ptr_val); + svld4(svbool_t_val, mfloat8_t_ptr_val); + svld4(svbool_t_val, uint8_t_ptr_val); + svld4(svbool_t_val, uint16_t_ptr_val); + svld4(svbool_t_val, uint32_t_ptr_val); + svld4(svbool_t_val, uint64_t_ptr_val); + svld4_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld4_f16(svbool_t_val, float16_t_ptr_val); + svld4_f32(svbool_t_val, float32_t_ptr_val); + svld4_f64(svbool_t_val, float64_t_ptr_val); + svld4_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld4_s8(svbool_t_val, int8_t_ptr_val); + svld4_s16(svbool_t_val, int16_t_ptr_val); + svld4_s32(svbool_t_val, int32_t_ptr_val); + svld4_s64(svbool_t_val, int64_t_ptr_val); + svld4_u8(svbool_t_val, uint8_t_ptr_val); + svld4_u16(svbool_t_val, uint16_t_ptr_val); + svld4_u32(svbool_t_val, uint32_t_ptr_val); + svld4_u64(svbool_t_val, uint64_t_ptr_val); + svld4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svld4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svld4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svld4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svld4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svld4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svld4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svld4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1(svbool_t_val, bfloat16_t_ptr_val); + svldnt1(svbool_t_val, float16_t_ptr_val); + svldnt1(svbool_t_val, float32_t_ptr_val); + svldnt1(svbool_t_val, float64_t_ptr_val); + svldnt1(svbool_t_val, int8_t_ptr_val); + svldnt1(svbool_t_val, int16_t_ptr_val); + svldnt1(svbool_t_val, int32_t_ptr_val); + svldnt1(svbool_t_val, int64_t_ptr_val); + svldnt1(svbool_t_val, mfloat8_t_ptr_val); + svldnt1(svbool_t_val, uint8_t_ptr_val); + svldnt1(svbool_t_val, uint16_t_ptr_val); + svldnt1(svbool_t_val, uint32_t_ptr_val); + svldnt1(svbool_t_val, uint64_t_ptr_val); + svldnt1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svldnt1_f16(svbool_t_val, float16_t_ptr_val); + svldnt1_f32(svbool_t_val, float32_t_ptr_val); + svldnt1_f64(svbool_t_val, float64_t_ptr_val); + svldnt1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svldnt1_s8(svbool_t_val, int8_t_ptr_val); + svldnt1_s16(svbool_t_val, int16_t_ptr_val); + svldnt1_s32(svbool_t_val, int32_t_ptr_val); + svldnt1_s64(svbool_t_val, int64_t_ptr_val); + svldnt1_u8(svbool_t_val, uint8_t_ptr_val); + svldnt1_u16(svbool_t_val, uint16_t_ptr_val); + svldnt1_u32(svbool_t_val, uint32_t_ptr_val); + svldnt1_u64(svbool_t_val, uint64_t_ptr_val); + svldnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svlen(svbfloat16_t_val); + svlen(svfloat16_t_val); + svlen(svfloat32_t_val); + svlen(svfloat64_t_val); + svlen(svint8_t_val); + svlen(svint16_t_val); + svlen(svint32_t_val); + svlen(svint64_t_val); + svlen(svuint8_t_val); + svlen(svuint16_t_val); + svlen(svuint32_t_val); + svlen(svuint64_t_val); + svlen_bf16(svbfloat16_t_val); + svlen_f16(svfloat16_t_val); + svlen_f32(svfloat32_t_val); + svlen_f64(svfloat64_t_val); + svlen_s8(svint8_t_val); + svlen_s16(svint16_t_val); + svlen_s32(svint32_t_val); + svlen_s64(svint64_t_val); + svlen_u8(svuint8_t_val); + svlen_u16(svuint16_t_val); + svlen_u32(svuint32_t_val); + svlen_u64(svuint64_t_val); + svlsl_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_s8_m(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s8_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_n_s16_m(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s16_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_n_s32_m(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s32_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_n_s64_m(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_s64_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_s8_m(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s8_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_s16_m(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s16_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_s32_m(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s32_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_s64_m(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_s64_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_s8_m(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s8_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_n_s16_m(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s16_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_n_s32_m(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_s32_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_s8_m(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s8_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_s16_m(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s16_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_s32_m(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_s32_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svint32_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsl_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svint64_t_val, uint64_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsl_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsl_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsl_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsl_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u8_m(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u8_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_n_u16_m(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u16_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_n_u32_m(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_n_u32_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_u8_m(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u8_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_u16_m(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u16_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_u32_m(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_u32_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_x(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint8_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint16_t_val, uint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, svuint64_t_val); + svlsr_wide_z(svbool_t_val, svuint32_t_val, uint64_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svlsr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svlsr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svlsr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svlsr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmad_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmad_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmad_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmad_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmad_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmad_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmad_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmad_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmax_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_x(svbool_t_val, svint8_t_val, int8_t_val); + svmax_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_x(svbool_t_val, svint16_t_val, int16_t_val); + svmax_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_x(svbool_t_val, svint32_t_val, int32_t_val); + svmax_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_x(svbool_t_val, svint64_t_val, int64_t_val); + svmax_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmax_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmax_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmax_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmax_z(svbool_t_val, svint8_t_val, int8_t_val); + svmax_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmax_z(svbool_t_val, svint16_t_val, int16_t_val); + svmax_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmax_z(svbool_t_val, svint32_t_val, int32_t_val); + svmax_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmax_z(svbool_t_val, svint64_t_val, int64_t_val); + svmax_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmax_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmax_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmax_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmax_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmax_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmax_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmax_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmax_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmaxnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmaxnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmaxnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmaxnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmaxnmv(svbool_t_val, svfloat16_t_val); + svmaxnmv(svbool_t_val, svfloat32_t_val); + svmaxnmv(svbool_t_val, svfloat64_t_val); + svmaxnmv_f16(svbool_t_val, svfloat16_t_val); + svmaxnmv_f32(svbool_t_val, svfloat32_t_val); + svmaxnmv_f64(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svfloat16_t_val); + svmaxv(svbool_t_val, svfloat32_t_val); + svmaxv(svbool_t_val, svfloat64_t_val); + svmaxv(svbool_t_val, svint8_t_val); + svmaxv(svbool_t_val, svint16_t_val); + svmaxv(svbool_t_val, svint32_t_val); + svmaxv(svbool_t_val, svint64_t_val); + svmaxv(svbool_t_val, svuint8_t_val); + svmaxv(svbool_t_val, svuint16_t_val); + svmaxv(svbool_t_val, svuint32_t_val); + svmaxv(svbool_t_val, svuint64_t_val); + svmaxv_f16(svbool_t_val, svfloat16_t_val); + svmaxv_f32(svbool_t_val, svfloat32_t_val); + svmaxv_f64(svbool_t_val, svfloat64_t_val); + svmaxv_s8(svbool_t_val, svint8_t_val); + svmaxv_s16(svbool_t_val, svint16_t_val); + svmaxv_s32(svbool_t_val, svint32_t_val); + svmaxv_s64(svbool_t_val, svint64_t_val); + svmaxv_u8(svbool_t_val, svuint8_t_val); + svmaxv_u16(svbool_t_val, svuint16_t_val); + svmaxv_u32(svbool_t_val, svuint32_t_val); + svmaxv_u64(svbool_t_val, svuint64_t_val); + svmin_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_x(svbool_t_val, svint8_t_val, int8_t_val); + svmin_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_x(svbool_t_val, svint16_t_val, int16_t_val); + svmin_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_x(svbool_t_val, svint32_t_val, int32_t_val); + svmin_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_x(svbool_t_val, svint64_t_val, int64_t_val); + svmin_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmin_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmin_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmin_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmin_z(svbool_t_val, svint8_t_val, int8_t_val); + svmin_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmin_z(svbool_t_val, svint16_t_val, int16_t_val); + svmin_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmin_z(svbool_t_val, svint32_t_val, int32_t_val); + svmin_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmin_z(svbool_t_val, svint64_t_val, int64_t_val); + svmin_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmin_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmin_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmin_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmin_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmin_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmin_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmin_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmin_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svminnm_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svminnm_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svminnm_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svminnm_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svminnmv(svbool_t_val, svfloat16_t_val); + svminnmv(svbool_t_val, svfloat32_t_val); + svminnmv(svbool_t_val, svfloat64_t_val); + svminnmv_f16(svbool_t_val, svfloat16_t_val); + svminnmv_f32(svbool_t_val, svfloat32_t_val); + svminnmv_f64(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svfloat16_t_val); + svminv(svbool_t_val, svfloat32_t_val); + svminv(svbool_t_val, svfloat64_t_val); + svminv(svbool_t_val, svint8_t_val); + svminv(svbool_t_val, svint16_t_val); + svminv(svbool_t_val, svint32_t_val); + svminv(svbool_t_val, svint64_t_val); + svminv(svbool_t_val, svuint8_t_val); + svminv(svbool_t_val, svuint16_t_val); + svminv(svbool_t_val, svuint32_t_val); + svminv(svbool_t_val, svuint64_t_val); + svminv_f16(svbool_t_val, svfloat16_t_val); + svminv_f32(svbool_t_val, svfloat32_t_val); + svminv_f64(svbool_t_val, svfloat64_t_val); + svminv_s8(svbool_t_val, svint8_t_val); + svminv_s16(svbool_t_val, svint16_t_val); + svminv_s32(svbool_t_val, svint32_t_val); + svminv_s64(svbool_t_val, svint64_t_val); + svminv_u8(svbool_t_val, svuint8_t_val); + svminv_u16(svbool_t_val, svuint16_t_val); + svminv_u32(svbool_t_val, svuint32_t_val); + svminv_u64(svbool_t_val, svuint64_t_val); + svmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmla_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmla_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmla_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmla_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmla_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmla_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmla_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmla_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmla_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmla_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_lane(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_lane_f16(svfloat16_t_val, svfloat16_t_val, svfloat16_t_val, 1); + svmls_lane_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val, 1); + svmls_lane_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val, 1); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmls_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmls_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmls_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmls_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmls_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmls_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmls_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmls_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmov_b_z(svbool_t_val, svbool_t_val); + svmov_z(svbool_t_val, svbool_t_val); + svmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_n_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_n_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_n_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_n_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_n_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_n_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_n_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_n_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_n_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_s8_m(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s8_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_s16_m(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s16_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_s32_m(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s32_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_s64_m(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_s64_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_x(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_x(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_x(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_x(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_x(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_x(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_x(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_x(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, int8_t_val); + svmsb_z(svbool_t_val, svint8_t_val, svint8_t_val, svint8_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, int16_t_val); + svmsb_z(svbool_t_val, svint16_t_val, svint16_t_val, svint16_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, int32_t_val); + svmsb_z(svbool_t_val, svint32_t_val, svint32_t_val, svint32_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, int64_t_val); + svmsb_z(svbool_t_val, svint64_t_val, svint64_t_val, svint64_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, svuint8_t_val); + svmsb_z(svbool_t_val, svuint8_t_val, svuint8_t_val, uint8_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, svuint16_t_val); + svmsb_z(svbool_t_val, svuint16_t_val, svuint16_t_val, uint16_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, svuint32_t_val); + svmsb_z(svbool_t_val, svuint32_t_val, svuint32_t_val, uint32_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, svuint64_t_val); + svmsb_z(svbool_t_val, svuint64_t_val, svuint64_t_val, uint64_t_val); + svmul_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_lane(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane(svfloat64_t_val, svfloat64_t_val, 1); + svmul_lane_f16(svfloat16_t_val, svfloat16_t_val, 1); + svmul_lane_f32(svfloat32_t_val, svfloat32_t_val, 1); + svmul_lane_f64(svfloat64_t_val, svfloat64_t_val, 1); + svmul_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_x(svbool_t_val, svint8_t_val, int8_t_val); + svmul_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_x(svbool_t_val, svint16_t_val, int16_t_val); + svmul_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_x(svbool_t_val, svint32_t_val, int32_t_val); + svmul_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_x(svbool_t_val, svint64_t_val, int64_t_val); + svmul_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmul_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmul_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmul_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmul_z(svbool_t_val, svint8_t_val, int8_t_val); + svmul_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmul_z(svbool_t_val, svint16_t_val, int16_t_val); + svmul_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmul_z(svbool_t_val, svint32_t_val, int32_t_val); + svmul_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmul_z(svbool_t_val, svint64_t_val, int64_t_val); + svmul_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmul_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmul_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmul_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmul_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmul_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmul_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmul_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmul_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_x(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_x(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_x(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_x(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_x(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_x(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_x(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulh_z(svbool_t_val, svint8_t_val, int8_t_val); + svmulh_z(svbool_t_val, svint8_t_val, svint8_t_val); + svmulh_z(svbool_t_val, svint16_t_val, int16_t_val); + svmulh_z(svbool_t_val, svint16_t_val, svint16_t_val); + svmulh_z(svbool_t_val, svint32_t_val, int32_t_val); + svmulh_z(svbool_t_val, svint32_t_val, svint32_t_val); + svmulh_z(svbool_t_val, svint64_t_val, int64_t_val); + svmulh_z(svbool_t_val, svint64_t_val, svint64_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmulh_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmulh_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svmulh_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svmulh_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svmulx_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svmulx_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svmulx_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svmulx_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svnand_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnand_z(svbool_t_val, svbool_t_val, svbool_t_val); + svneg_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_f16_x(svbool_t_val, svfloat16_t_val); + svneg_f16_z(svbool_t_val, svfloat16_t_val); + svneg_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_f32_x(svbool_t_val, svfloat32_t_val); + svneg_f32_z(svbool_t_val, svfloat32_t_val); + svneg_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_f64_x(svbool_t_val, svfloat64_t_val); + svneg_f64_z(svbool_t_val, svfloat64_t_val); + svneg_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svneg_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svneg_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svneg_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svneg_s8_x(svbool_t_val, svint8_t_val); + svneg_s8_z(svbool_t_val, svint8_t_val); + svneg_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svneg_s16_x(svbool_t_val, svint16_t_val); + svneg_s16_z(svbool_t_val, svint16_t_val); + svneg_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svneg_s32_x(svbool_t_val, svint32_t_val); + svneg_s32_z(svbool_t_val, svint32_t_val); + svneg_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svneg_s64_x(svbool_t_val, svint64_t_val); + svneg_s64_z(svbool_t_val, svint64_t_val); + svneg_x(svbool_t_val, svfloat16_t_val); + svneg_x(svbool_t_val, svfloat32_t_val); + svneg_x(svbool_t_val, svfloat64_t_val); + svneg_x(svbool_t_val, svint8_t_val); + svneg_x(svbool_t_val, svint16_t_val); + svneg_x(svbool_t_val, svint32_t_val); + svneg_x(svbool_t_val, svint64_t_val); + svneg_z(svbool_t_val, svfloat16_t_val); + svneg_z(svbool_t_val, svfloat32_t_val); + svneg_z(svbool_t_val, svfloat64_t_val); + svneg_z(svbool_t_val, svint8_t_val); + svneg_z(svbool_t_val, svint16_t_val); + svneg_z(svbool_t_val, svint32_t_val); + svneg_z(svbool_t_val, svint64_t_val); + svnmad_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmad_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmad_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmad_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmla_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmla_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmla_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmls_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmls_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmls_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_n_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_n_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_n_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_n_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, float16_t_val); + svnmsb_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val, svfloat16_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, float32_t_val); + svnmsb_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, float64_t_val); + svnmsb_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svnor_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnor_z(svbool_t_val, svbool_t_val, svbool_t_val); + svnot_b_z(svbool_t_val, svbool_t_val); + svnot_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svnot_s8_x(svbool_t_val, svint8_t_val); + svnot_s8_z(svbool_t_val, svint8_t_val); + svnot_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svnot_s16_x(svbool_t_val, svint16_t_val); + svnot_s16_z(svbool_t_val, svint16_t_val); + svnot_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svnot_s32_x(svbool_t_val, svint32_t_val); + svnot_s32_z(svbool_t_val, svint32_t_val); + svnot_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svnot_s64_x(svbool_t_val, svint64_t_val); + svnot_s64_z(svbool_t_val, svint64_t_val); + svnot_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svnot_u8_x(svbool_t_val, svuint8_t_val); + svnot_u8_z(svbool_t_val, svuint8_t_val); + svnot_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svnot_u16_x(svbool_t_val, svuint16_t_val); + svnot_u16_z(svbool_t_val, svuint16_t_val); + svnot_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svnot_u32_x(svbool_t_val, svuint32_t_val); + svnot_u32_z(svbool_t_val, svuint32_t_val); + svnot_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svnot_u64_x(svbool_t_val, svuint64_t_val); + svnot_u64_z(svbool_t_val, svuint64_t_val); + svnot_x(svbool_t_val, svint8_t_val); + svnot_x(svbool_t_val, svint16_t_val); + svnot_x(svbool_t_val, svint32_t_val); + svnot_x(svbool_t_val, svint64_t_val); + svnot_x(svbool_t_val, svuint8_t_val); + svnot_x(svbool_t_val, svuint16_t_val); + svnot_x(svbool_t_val, svuint32_t_val); + svnot_x(svbool_t_val, svuint64_t_val); + svnot_z(svbool_t_val, svbool_t_val); + svnot_z(svbool_t_val, svint8_t_val); + svnot_z(svbool_t_val, svint16_t_val); + svnot_z(svbool_t_val, svint32_t_val); + svnot_z(svbool_t_val, svint64_t_val); + svnot_z(svbool_t_val, svuint8_t_val); + svnot_z(svbool_t_val, svuint16_t_val); + svnot_z(svbool_t_val, svuint32_t_val); + svnot_z(svbool_t_val, svuint64_t_val); + svorn_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorn_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_b_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svint8_t_val, int8_t_val); + svorr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_x(svbool_t_val, svint16_t_val, int16_t_val); + svorr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_x(svbool_t_val, svint32_t_val, int32_t_val); + svorr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_x(svbool_t_val, svint64_t_val, int64_t_val); + svorr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svorr_z(svbool_t_val, svbool_t_val, svbool_t_val); + svorr_z(svbool_t_val, svint8_t_val, int8_t_val); + svorr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svorr_z(svbool_t_val, svint16_t_val, int16_t_val); + svorr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svorr_z(svbool_t_val, svint32_t_val, int32_t_val); + svorr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svorr_z(svbool_t_val, svint64_t_val, int64_t_val); + svorr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svorr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svorr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svorr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svorr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svorr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svorr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svorr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svorr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svorv(svbool_t_val, svint8_t_val); + svorv(svbool_t_val, svint16_t_val); + svorv(svbool_t_val, svint32_t_val); + svorv(svbool_t_val, svint64_t_val); + svorv(svbool_t_val, svuint8_t_val); + svorv(svbool_t_val, svuint16_t_val); + svorv(svbool_t_val, svuint32_t_val); + svorv(svbool_t_val, svuint64_t_val); + svorv_s8(svbool_t_val, svint8_t_val); + svorv_s16(svbool_t_val, svint16_t_val); + svorv_s32(svbool_t_val, svint32_t_val); + svorv_s64(svbool_t_val, svint64_t_val); + svorv_u8(svbool_t_val, svuint8_t_val); + svorv_u16(svbool_t_val, svuint16_t_val); + svorv_u32(svbool_t_val, svuint32_t_val); + svorv_u64(svbool_t_val, svuint64_t_val); + svpfalse(); + svpfalse_b(); + svpfirst(svbool_t_val, svbool_t_val); + svpfirst_b(svbool_t_val, svbool_t_val); + svpnext_b8(svbool_t_val, svbool_t_val); + svpnext_b16(svbool_t_val, svbool_t_val); + svpnext_b32(svbool_t_val, svbool_t_val); + svpnext_b64(svbool_t_val, svbool_t_val); + svprfb(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfb_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfd(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfd_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfh(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfh_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svprfw(svbool_t_val, void_ptr_val, SV_PSTL1KEEP); + svprfw_vnum(svbool_t_val, void_ptr_val, int64_t_val, SV_PSTL1KEEP); + svptest_any(svbool_t_val, svbool_t_val); + svptest_first(svbool_t_val, svbool_t_val); + svptest_last(svbool_t_val, svbool_t_val); + svptrue_b8(); + svptrue_b16(); + svptrue_b32(); + svptrue_b64(); + svptrue_pat_b8(SV_MUL3); + svptrue_pat_b16(SV_MUL3); + svptrue_pat_b32(SV_MUL3); + svptrue_pat_b64(SV_MUL3); + svqadd(svint8_t_val, int8_t_val); + svqadd(svint8_t_val, svint8_t_val); + svqadd(svint16_t_val, int16_t_val); + svqadd(svint16_t_val, svint16_t_val); + svqadd(svint32_t_val, int32_t_val); + svqadd(svint32_t_val, svint32_t_val); + svqadd(svint64_t_val, int64_t_val); + svqadd(svint64_t_val, svint64_t_val); + svqadd(svuint8_t_val, svuint8_t_val); + svqadd(svuint8_t_val, uint8_t_val); + svqadd(svuint16_t_val, svuint16_t_val); + svqadd(svuint16_t_val, uint16_t_val); + svqadd(svuint32_t_val, svuint32_t_val); + svqadd(svuint32_t_val, uint32_t_val); + svqadd(svuint64_t_val, svuint64_t_val); + svqadd(svuint64_t_val, uint64_t_val); + svqadd_n_s8(svint8_t_val, int8_t_val); + svqadd_n_s16(svint16_t_val, int16_t_val); + svqadd_n_s32(svint32_t_val, int32_t_val); + svqadd_n_s64(svint64_t_val, int64_t_val); + svqadd_n_u8(svuint8_t_val, uint8_t_val); + svqadd_n_u16(svuint16_t_val, uint16_t_val); + svqadd_n_u32(svuint32_t_val, uint32_t_val); + svqadd_n_u64(svuint64_t_val, uint64_t_val); + svqadd_s8(svint8_t_val, svint8_t_val); + svqadd_s16(svint16_t_val, svint16_t_val); + svqadd_s32(svint32_t_val, svint32_t_val); + svqadd_s64(svint64_t_val, svint64_t_val); + svqadd_u8(svuint8_t_val, svuint8_t_val); + svqadd_u16(svuint16_t_val, svuint16_t_val); + svqadd_u32(svuint32_t_val, svuint32_t_val); + svqadd_u64(svuint64_t_val, svuint64_t_val); + svqdecb(int32_t_val, 2); + svqdecb(int64_t_val, 2); + svqdecb(uint32_t_val, 2); + svqdecb(uint64_t_val, 2); + svqdecb_n_s32(int32_t_val, 2); + svqdecb_n_s64(int64_t_val, 2); + svqdecb_n_u32(uint32_t_val, 2); + svqdecb_n_u64(uint64_t_val, 2); + svqdecb_pat(int32_t_val, SV_MUL3, 2); + svqdecb_pat(int64_t_val, SV_MUL3, 2); + svqdecb_pat(uint32_t_val, SV_MUL3, 2); + svqdecb_pat(uint64_t_val, SV_MUL3, 2); + svqdecb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd(int32_t_val, 2); + svqdecd(int64_t_val, 2); + svqdecd(svint64_t_val, 2); + svqdecd(svuint64_t_val, 2); + svqdecd(uint32_t_val, 2); + svqdecd(uint64_t_val, 2); + svqdecd_n_s32(int32_t_val, 2); + svqdecd_n_s64(int64_t_val, 2); + svqdecd_n_u32(uint32_t_val, 2); + svqdecd_n_u64(uint64_t_val, 2); + svqdecd_pat(int32_t_val, SV_MUL3, 2); + svqdecd_pat(int64_t_val, SV_MUL3, 2); + svqdecd_pat(svint64_t_val, SV_MUL3, 2); + svqdecd_pat(svuint64_t_val, SV_MUL3, 2); + svqdecd_pat(uint32_t_val, SV_MUL3, 2); + svqdecd_pat(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqdecd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqdecd_s64(svint64_t_val, 2); + svqdecd_u64(svuint64_t_val, 2); + svqdech(int32_t_val, 2); + svqdech(int64_t_val, 2); + svqdech(svint16_t_val, 2); + svqdech(svuint16_t_val, 2); + svqdech(uint32_t_val, 2); + svqdech(uint64_t_val, 2); + svqdech_n_s32(int32_t_val, 2); + svqdech_n_s64(int64_t_val, 2); + svqdech_n_u32(uint32_t_val, 2); + svqdech_n_u64(uint64_t_val, 2); + svqdech_pat(int32_t_val, SV_MUL3, 2); + svqdech_pat(int64_t_val, SV_MUL3, 2); + svqdech_pat(svint16_t_val, SV_MUL3, 2); + svqdech_pat(svuint16_t_val, SV_MUL3, 2); + svqdech_pat(uint32_t_val, SV_MUL3, 2); + svqdech_pat(uint64_t_val, SV_MUL3, 2); + svqdech_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdech_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdech_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdech_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdech_pat_s16(svint16_t_val, SV_MUL3, 2); + svqdech_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqdech_s16(svint16_t_val, 2); + svqdech_u16(svuint16_t_val, 2); + svqdecp(svint16_t_val, svbool_t_val); + svqdecp(svint32_t_val, svbool_t_val); + svqdecp(svint64_t_val, svbool_t_val); + svqdecp(svuint16_t_val, svbool_t_val); + svqdecp(svuint32_t_val, svbool_t_val); + svqdecp(svuint64_t_val, svbool_t_val); + svqdecp_b8(int32_t_val, svbool_t_val); + svqdecp_b8(int64_t_val, svbool_t_val); + svqdecp_b8(uint32_t_val, svbool_t_val); + svqdecp_b8(uint64_t_val, svbool_t_val); + svqdecp_b16(int32_t_val, svbool_t_val); + svqdecp_b16(int64_t_val, svbool_t_val); + svqdecp_b16(uint32_t_val, svbool_t_val); + svqdecp_b16(uint64_t_val, svbool_t_val); + svqdecp_b32(int32_t_val, svbool_t_val); + svqdecp_b32(int64_t_val, svbool_t_val); + svqdecp_b32(uint32_t_val, svbool_t_val); + svqdecp_b32(uint64_t_val, svbool_t_val); + svqdecp_b64(int32_t_val, svbool_t_val); + svqdecp_b64(int64_t_val, svbool_t_val); + svqdecp_b64(uint32_t_val, svbool_t_val); + svqdecp_b64(uint64_t_val, svbool_t_val); + svqdecp_n_s32_b8(int32_t_val, svbool_t_val); + svqdecp_n_s32_b16(int32_t_val, svbool_t_val); + svqdecp_n_s32_b32(int32_t_val, svbool_t_val); + svqdecp_n_s32_b64(int32_t_val, svbool_t_val); + svqdecp_n_s64_b8(int64_t_val, svbool_t_val); + svqdecp_n_s64_b16(int64_t_val, svbool_t_val); + svqdecp_n_s64_b32(int64_t_val, svbool_t_val); + svqdecp_n_s64_b64(int64_t_val, svbool_t_val); + svqdecp_n_u32_b8(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b16(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b32(uint32_t_val, svbool_t_val); + svqdecp_n_u32_b64(uint32_t_val, svbool_t_val); + svqdecp_n_u64_b8(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b16(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b32(uint64_t_val, svbool_t_val); + svqdecp_n_u64_b64(uint64_t_val, svbool_t_val); + svqdecp_s16(svint16_t_val, svbool_t_val); + svqdecp_s32(svint32_t_val, svbool_t_val); + svqdecp_s64(svint64_t_val, svbool_t_val); + svqdecp_u16(svuint16_t_val, svbool_t_val); + svqdecp_u32(svuint32_t_val, svbool_t_val); + svqdecp_u64(svuint64_t_val, svbool_t_val); + svqdecw(int32_t_val, 2); + svqdecw(int64_t_val, 2); + svqdecw(svint32_t_val, 2); + svqdecw(svuint32_t_val, 2); + svqdecw(uint32_t_val, 2); + svqdecw(uint64_t_val, 2); + svqdecw_n_s32(int32_t_val, 2); + svqdecw_n_s64(int64_t_val, 2); + svqdecw_n_u32(uint32_t_val, 2); + svqdecw_n_u64(uint64_t_val, 2); + svqdecw_pat(int32_t_val, SV_MUL3, 2); + svqdecw_pat(int64_t_val, SV_MUL3, 2); + svqdecw_pat(svint32_t_val, SV_MUL3, 2); + svqdecw_pat(svuint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint32_t_val, SV_MUL3, 2); + svqdecw_pat(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqdecw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqdecw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqdecw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqdecw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqdecw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqdecw_s32(svint32_t_val, 2); + svqdecw_u32(svuint32_t_val, 2); + svqincb(int32_t_val, 2); + svqincb(int64_t_val, 2); + svqincb(uint32_t_val, 2); + svqincb(uint64_t_val, 2); + svqincb_n_s32(int32_t_val, 2); + svqincb_n_s64(int64_t_val, 2); + svqincb_n_u32(uint32_t_val, 2); + svqincb_n_u64(uint64_t_val, 2); + svqincb_pat(int32_t_val, SV_MUL3, 2); + svqincb_pat(int64_t_val, SV_MUL3, 2); + svqincb_pat(uint32_t_val, SV_MUL3, 2); + svqincb_pat(uint64_t_val, SV_MUL3, 2); + svqincb_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincb_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincb_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincb_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd(int32_t_val, 2); + svqincd(int64_t_val, 2); + svqincd(svint64_t_val, 2); + svqincd(svuint64_t_val, 2); + svqincd(uint32_t_val, 2); + svqincd(uint64_t_val, 2); + svqincd_n_s32(int32_t_val, 2); + svqincd_n_s64(int64_t_val, 2); + svqincd_n_u32(uint32_t_val, 2); + svqincd_n_u64(uint64_t_val, 2); + svqincd_pat(int32_t_val, SV_MUL3, 2); + svqincd_pat(int64_t_val, SV_MUL3, 2); + svqincd_pat(svint64_t_val, SV_MUL3, 2); + svqincd_pat(svuint64_t_val, SV_MUL3, 2); + svqincd_pat(uint32_t_val, SV_MUL3, 2); + svqincd_pat(uint64_t_val, SV_MUL3, 2); + svqincd_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincd_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincd_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincd_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincd_pat_s64(svint64_t_val, SV_MUL3, 2); + svqincd_pat_u64(svuint64_t_val, SV_MUL3, 2); + svqincd_s64(svint64_t_val, 2); + svqincd_u64(svuint64_t_val, 2); + svqinch(int32_t_val, 2); + svqinch(int64_t_val, 2); + svqinch(svint16_t_val, 2); + svqinch(svuint16_t_val, 2); + svqinch(uint32_t_val, 2); + svqinch(uint64_t_val, 2); + svqinch_n_s32(int32_t_val, 2); + svqinch_n_s64(int64_t_val, 2); + svqinch_n_u32(uint32_t_val, 2); + svqinch_n_u64(uint64_t_val, 2); + svqinch_pat(int32_t_val, SV_MUL3, 2); + svqinch_pat(int64_t_val, SV_MUL3, 2); + svqinch_pat(svint16_t_val, SV_MUL3, 2); + svqinch_pat(svuint16_t_val, SV_MUL3, 2); + svqinch_pat(uint32_t_val, SV_MUL3, 2); + svqinch_pat(uint64_t_val, SV_MUL3, 2); + svqinch_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqinch_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqinch_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqinch_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqinch_pat_s16(svint16_t_val, SV_MUL3, 2); + svqinch_pat_u16(svuint16_t_val, SV_MUL3, 2); + svqinch_s16(svint16_t_val, 2); + svqinch_u16(svuint16_t_val, 2); + svqincp(svint16_t_val, svbool_t_val); + svqincp(svint32_t_val, svbool_t_val); + svqincp(svint64_t_val, svbool_t_val); + svqincp(svuint16_t_val, svbool_t_val); + svqincp(svuint32_t_val, svbool_t_val); + svqincp(svuint64_t_val, svbool_t_val); + svqincp_b8(int32_t_val, svbool_t_val); + svqincp_b8(int64_t_val, svbool_t_val); + svqincp_b8(uint32_t_val, svbool_t_val); + svqincp_b8(uint64_t_val, svbool_t_val); + svqincp_b16(int32_t_val, svbool_t_val); + svqincp_b16(int64_t_val, svbool_t_val); + svqincp_b16(uint32_t_val, svbool_t_val); + svqincp_b16(uint64_t_val, svbool_t_val); + svqincp_b32(int32_t_val, svbool_t_val); + svqincp_b32(int64_t_val, svbool_t_val); + svqincp_b32(uint32_t_val, svbool_t_val); + svqincp_b32(uint64_t_val, svbool_t_val); + svqincp_b64(int32_t_val, svbool_t_val); + svqincp_b64(int64_t_val, svbool_t_val); + svqincp_b64(uint32_t_val, svbool_t_val); + svqincp_b64(uint64_t_val, svbool_t_val); + svqincp_n_s32_b8(int32_t_val, svbool_t_val); + svqincp_n_s32_b16(int32_t_val, svbool_t_val); + svqincp_n_s32_b32(int32_t_val, svbool_t_val); + svqincp_n_s32_b64(int32_t_val, svbool_t_val); + svqincp_n_s64_b8(int64_t_val, svbool_t_val); + svqincp_n_s64_b16(int64_t_val, svbool_t_val); + svqincp_n_s64_b32(int64_t_val, svbool_t_val); + svqincp_n_s64_b64(int64_t_val, svbool_t_val); + svqincp_n_u32_b8(uint32_t_val, svbool_t_val); + svqincp_n_u32_b16(uint32_t_val, svbool_t_val); + svqincp_n_u32_b32(uint32_t_val, svbool_t_val); + svqincp_n_u32_b64(uint32_t_val, svbool_t_val); + svqincp_n_u64_b8(uint64_t_val, svbool_t_val); + svqincp_n_u64_b16(uint64_t_val, svbool_t_val); + svqincp_n_u64_b32(uint64_t_val, svbool_t_val); + svqincp_n_u64_b64(uint64_t_val, svbool_t_val); + svqincp_s16(svint16_t_val, svbool_t_val); + svqincp_s32(svint32_t_val, svbool_t_val); + svqincp_s64(svint64_t_val, svbool_t_val); + svqincp_u16(svuint16_t_val, svbool_t_val); + svqincp_u32(svuint32_t_val, svbool_t_val); + svqincp_u64(svuint64_t_val, svbool_t_val); + svqincw(int32_t_val, 2); + svqincw(int64_t_val, 2); + svqincw(svint32_t_val, 2); + svqincw(svuint32_t_val, 2); + svqincw(uint32_t_val, 2); + svqincw(uint64_t_val, 2); + svqincw_n_s32(int32_t_val, 2); + svqincw_n_s64(int64_t_val, 2); + svqincw_n_u32(uint32_t_val, 2); + svqincw_n_u64(uint64_t_val, 2); + svqincw_pat(int32_t_val, SV_MUL3, 2); + svqincw_pat(int64_t_val, SV_MUL3, 2); + svqincw_pat(svint32_t_val, SV_MUL3, 2); + svqincw_pat(svuint32_t_val, SV_MUL3, 2); + svqincw_pat(uint32_t_val, SV_MUL3, 2); + svqincw_pat(uint64_t_val, SV_MUL3, 2); + svqincw_pat_n_s32(int32_t_val, SV_MUL3, 2); + svqincw_pat_n_s64(int64_t_val, SV_MUL3, 2); + svqincw_pat_n_u32(uint32_t_val, SV_MUL3, 2); + svqincw_pat_n_u64(uint64_t_val, SV_MUL3, 2); + svqincw_pat_s32(svint32_t_val, SV_MUL3, 2); + svqincw_pat_u32(svuint32_t_val, SV_MUL3, 2); + svqincw_s32(svint32_t_val, 2); + svqincw_u32(svuint32_t_val, 2); + svqsub(svint8_t_val, int8_t_val); + svqsub(svint8_t_val, svint8_t_val); + svqsub(svint16_t_val, int16_t_val); + svqsub(svint16_t_val, svint16_t_val); + svqsub(svint32_t_val, int32_t_val); + svqsub(svint32_t_val, svint32_t_val); + svqsub(svint64_t_val, int64_t_val); + svqsub(svint64_t_val, svint64_t_val); + svqsub(svuint8_t_val, svuint8_t_val); + svqsub(svuint8_t_val, uint8_t_val); + svqsub(svuint16_t_val, svuint16_t_val); + svqsub(svuint16_t_val, uint16_t_val); + svqsub(svuint32_t_val, svuint32_t_val); + svqsub(svuint32_t_val, uint32_t_val); + svqsub(svuint64_t_val, svuint64_t_val); + svqsub(svuint64_t_val, uint64_t_val); + svqsub_n_s8(svint8_t_val, int8_t_val); + svqsub_n_s16(svint16_t_val, int16_t_val); + svqsub_n_s32(svint32_t_val, int32_t_val); + svqsub_n_s64(svint64_t_val, int64_t_val); + svqsub_n_u8(svuint8_t_val, uint8_t_val); + svqsub_n_u16(svuint16_t_val, uint16_t_val); + svqsub_n_u32(svuint32_t_val, uint32_t_val); + svqsub_n_u64(svuint64_t_val, uint64_t_val); + svqsub_s8(svint8_t_val, svint8_t_val); + svqsub_s16(svint16_t_val, svint16_t_val); + svqsub_s32(svint32_t_val, svint32_t_val); + svqsub_s64(svint64_t_val, svint64_t_val); + svqsub_u8(svuint8_t_val, svuint8_t_val); + svqsub_u16(svuint16_t_val, svuint16_t_val); + svqsub_u32(svuint32_t_val, svuint32_t_val); + svqsub_u64(svuint64_t_val, svuint64_t_val); + svrbit_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_s8_m(svint8_t_val, svbool_t_val, svint8_t_val); + svrbit_s8_x(svbool_t_val, svint8_t_val); + svrbit_s8_z(svbool_t_val, svint8_t_val); + svrbit_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrbit_s16_x(svbool_t_val, svint16_t_val); + svrbit_s16_z(svbool_t_val, svint16_t_val); + svrbit_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrbit_s32_x(svbool_t_val, svint32_t_val); + svrbit_s32_z(svbool_t_val, svint32_t_val); + svrbit_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrbit_s64_x(svbool_t_val, svint64_t_val); + svrbit_s64_z(svbool_t_val, svint64_t_val); + svrbit_u8_m(svuint8_t_val, svbool_t_val, svuint8_t_val); + svrbit_u8_x(svbool_t_val, svuint8_t_val); + svrbit_u8_z(svbool_t_val, svuint8_t_val); + svrbit_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrbit_u16_x(svbool_t_val, svuint16_t_val); + svrbit_u16_z(svbool_t_val, svuint16_t_val); + svrbit_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrbit_u32_x(svbool_t_val, svuint32_t_val); + svrbit_u32_z(svbool_t_val, svuint32_t_val); + svrbit_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrbit_u64_x(svbool_t_val, svuint64_t_val); + svrbit_u64_z(svbool_t_val, svuint64_t_val); + svrbit_x(svbool_t_val, svint8_t_val); + svrbit_x(svbool_t_val, svint16_t_val); + svrbit_x(svbool_t_val, svint32_t_val); + svrbit_x(svbool_t_val, svint64_t_val); + svrbit_x(svbool_t_val, svuint8_t_val); + svrbit_x(svbool_t_val, svuint16_t_val); + svrbit_x(svbool_t_val, svuint32_t_val); + svrbit_x(svbool_t_val, svuint64_t_val); + svrbit_z(svbool_t_val, svint8_t_val); + svrbit_z(svbool_t_val, svint16_t_val); + svrbit_z(svbool_t_val, svint32_t_val); + svrbit_z(svbool_t_val, svint64_t_val); + svrbit_z(svbool_t_val, svuint8_t_val); + svrbit_z(svbool_t_val, svuint16_t_val); + svrbit_z(svbool_t_val, svuint32_t_val); + svrbit_z(svbool_t_val, svuint64_t_val); + svrecpe(svfloat16_t_val); + svrecpe(svfloat32_t_val); + svrecpe(svfloat64_t_val); + svrecpe_f16(svfloat16_t_val); + svrecpe_f32(svfloat32_t_val); + svrecpe_f64(svfloat64_t_val); + svrecps(svfloat16_t_val, svfloat16_t_val); + svrecps(svfloat32_t_val, svfloat32_t_val); + svrecps(svfloat64_t_val, svfloat64_t_val); + svrecps_f16(svfloat16_t_val, svfloat16_t_val); + svrecps_f32(svfloat32_t_val, svfloat32_t_val); + svrecps_f64(svfloat64_t_val, svfloat64_t_val); + svrecpx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_f16_x(svbool_t_val, svfloat16_t_val); + svrecpx_f16_z(svbool_t_val, svfloat16_t_val); + svrecpx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_f32_x(svbool_t_val, svfloat32_t_val); + svrecpx_f32_z(svbool_t_val, svfloat32_t_val); + svrecpx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_f64_x(svbool_t_val, svfloat64_t_val); + svrecpx_f64_z(svbool_t_val, svfloat64_t_val); + svrecpx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrecpx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrecpx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrecpx_x(svbool_t_val, svfloat16_t_val); + svrecpx_x(svbool_t_val, svfloat32_t_val); + svrecpx_x(svbool_t_val, svfloat64_t_val); + svrecpx_z(svbool_t_val, svfloat16_t_val); + svrecpx_z(svbool_t_val, svfloat32_t_val); + svrecpx_z(svbool_t_val, svfloat64_t_val); + svrev(svbfloat16_t_val); + svrev(svfloat16_t_val); + svrev(svfloat32_t_val); + svrev(svfloat64_t_val); + svrev(svint8_t_val); + svrev(svint16_t_val); + svrev(svint32_t_val); + svrev(svint64_t_val); + svrev(svuint8_t_val); + svrev(svuint16_t_val); + svrev(svuint32_t_val); + svrev(svuint64_t_val); + svrev_b8(svbool_t_val); + svrev_b16(svbool_t_val); + svrev_b32(svbool_t_val); + svrev_b64(svbool_t_val); + svrev_bf16(svbfloat16_t_val); + svrev_f16(svfloat16_t_val); + svrev_f32(svfloat32_t_val); + svrev_f64(svfloat64_t_val); + svrev_s8(svint8_t_val); + svrev_s16(svint16_t_val); + svrev_s32(svint32_t_val); + svrev_s64(svint64_t_val); + svrev_u8(svuint8_t_val); + svrev_u16(svuint16_t_val); + svrev_u32(svuint32_t_val); + svrev_u64(svuint64_t_val); + svrevb_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_s16_m(svint16_t_val, svbool_t_val, svint16_t_val); + svrevb_s16_x(svbool_t_val, svint16_t_val); + svrevb_s16_z(svbool_t_val, svint16_t_val); + svrevb_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevb_s32_x(svbool_t_val, svint32_t_val); + svrevb_s32_z(svbool_t_val, svint32_t_val); + svrevb_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevb_s64_x(svbool_t_val, svint64_t_val); + svrevb_s64_z(svbool_t_val, svint64_t_val); + svrevb_u16_m(svuint16_t_val, svbool_t_val, svuint16_t_val); + svrevb_u16_x(svbool_t_val, svuint16_t_val); + svrevb_u16_z(svbool_t_val, svuint16_t_val); + svrevb_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevb_u32_x(svbool_t_val, svuint32_t_val); + svrevb_u32_z(svbool_t_val, svuint32_t_val); + svrevb_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevb_u64_x(svbool_t_val, svuint64_t_val); + svrevb_u64_z(svbool_t_val, svuint64_t_val); + svrevb_x(svbool_t_val, svint16_t_val); + svrevb_x(svbool_t_val, svint32_t_val); + svrevb_x(svbool_t_val, svint64_t_val); + svrevb_x(svbool_t_val, svuint16_t_val); + svrevb_x(svbool_t_val, svuint32_t_val); + svrevb_x(svbool_t_val, svuint64_t_val); + svrevb_z(svbool_t_val, svint16_t_val); + svrevb_z(svbool_t_val, svint32_t_val); + svrevb_z(svbool_t_val, svint64_t_val); + svrevb_z(svbool_t_val, svuint16_t_val); + svrevb_z(svbool_t_val, svuint32_t_val); + svrevb_z(svbool_t_val, svuint64_t_val); + svrevh_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_s32_m(svint32_t_val, svbool_t_val, svint32_t_val); + svrevh_s32_x(svbool_t_val, svint32_t_val); + svrevh_s32_z(svbool_t_val, svint32_t_val); + svrevh_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevh_s64_x(svbool_t_val, svint64_t_val); + svrevh_s64_z(svbool_t_val, svint64_t_val); + svrevh_u32_m(svuint32_t_val, svbool_t_val, svuint32_t_val); + svrevh_u32_x(svbool_t_val, svuint32_t_val); + svrevh_u32_z(svbool_t_val, svuint32_t_val); + svrevh_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevh_u64_x(svbool_t_val, svuint64_t_val); + svrevh_u64_z(svbool_t_val, svuint64_t_val); + svrevh_x(svbool_t_val, svint32_t_val); + svrevh_x(svbool_t_val, svint64_t_val); + svrevh_x(svbool_t_val, svuint32_t_val); + svrevh_x(svbool_t_val, svuint64_t_val); + svrevh_z(svbool_t_val, svint32_t_val); + svrevh_z(svbool_t_val, svint64_t_val); + svrevh_z(svbool_t_val, svuint32_t_val); + svrevh_z(svbool_t_val, svuint64_t_val); + svrevw_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_s64_m(svint64_t_val, svbool_t_val, svint64_t_val); + svrevw_s64_x(svbool_t_val, svint64_t_val); + svrevw_s64_z(svbool_t_val, svint64_t_val); + svrevw_u64_m(svuint64_t_val, svbool_t_val, svuint64_t_val); + svrevw_u64_x(svbool_t_val, svuint64_t_val); + svrevw_u64_z(svbool_t_val, svuint64_t_val); + svrevw_x(svbool_t_val, svint64_t_val); + svrevw_x(svbool_t_val, svuint64_t_val); + svrevw_z(svbool_t_val, svint64_t_val); + svrevw_z(svbool_t_val, svuint64_t_val); + svrinta_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_f16_x(svbool_t_val, svfloat16_t_val); + svrinta_f16_z(svbool_t_val, svfloat16_t_val); + svrinta_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_f32_x(svbool_t_val, svfloat32_t_val); + svrinta_f32_z(svbool_t_val, svfloat32_t_val); + svrinta_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_f64_x(svbool_t_val, svfloat64_t_val); + svrinta_f64_z(svbool_t_val, svfloat64_t_val); + svrinta_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinta_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinta_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinta_x(svbool_t_val, svfloat16_t_val); + svrinta_x(svbool_t_val, svfloat32_t_val); + svrinta_x(svbool_t_val, svfloat64_t_val); + svrinta_z(svbool_t_val, svfloat16_t_val); + svrinta_z(svbool_t_val, svfloat32_t_val); + svrinta_z(svbool_t_val, svfloat64_t_val); + svrinti_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_f16_x(svbool_t_val, svfloat16_t_val); + svrinti_f16_z(svbool_t_val, svfloat16_t_val); + svrinti_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_f32_x(svbool_t_val, svfloat32_t_val); + svrinti_f32_z(svbool_t_val, svfloat32_t_val); + svrinti_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_f64_x(svbool_t_val, svfloat64_t_val); + svrinti_f64_z(svbool_t_val, svfloat64_t_val); + svrinti_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrinti_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrinti_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrinti_x(svbool_t_val, svfloat16_t_val); + svrinti_x(svbool_t_val, svfloat32_t_val); + svrinti_x(svbool_t_val, svfloat64_t_val); + svrinti_z(svbool_t_val, svfloat16_t_val); + svrinti_z(svbool_t_val, svfloat32_t_val); + svrinti_z(svbool_t_val, svfloat64_t_val); + svrintm_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_f16_x(svbool_t_val, svfloat16_t_val); + svrintm_f16_z(svbool_t_val, svfloat16_t_val); + svrintm_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_f32_x(svbool_t_val, svfloat32_t_val); + svrintm_f32_z(svbool_t_val, svfloat32_t_val); + svrintm_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_f64_x(svbool_t_val, svfloat64_t_val); + svrintm_f64_z(svbool_t_val, svfloat64_t_val); + svrintm_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintm_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintm_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintm_x(svbool_t_val, svfloat16_t_val); + svrintm_x(svbool_t_val, svfloat32_t_val); + svrintm_x(svbool_t_val, svfloat64_t_val); + svrintm_z(svbool_t_val, svfloat16_t_val); + svrintm_z(svbool_t_val, svfloat32_t_val); + svrintm_z(svbool_t_val, svfloat64_t_val); + svrintn_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_f16_x(svbool_t_val, svfloat16_t_val); + svrintn_f16_z(svbool_t_val, svfloat16_t_val); + svrintn_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_f32_x(svbool_t_val, svfloat32_t_val); + svrintn_f32_z(svbool_t_val, svfloat32_t_val); + svrintn_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_f64_x(svbool_t_val, svfloat64_t_val); + svrintn_f64_z(svbool_t_val, svfloat64_t_val); + svrintn_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintn_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintn_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintn_x(svbool_t_val, svfloat16_t_val); + svrintn_x(svbool_t_val, svfloat32_t_val); + svrintn_x(svbool_t_val, svfloat64_t_val); + svrintn_z(svbool_t_val, svfloat16_t_val); + svrintn_z(svbool_t_val, svfloat32_t_val); + svrintn_z(svbool_t_val, svfloat64_t_val); + svrintp_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_f16_x(svbool_t_val, svfloat16_t_val); + svrintp_f16_z(svbool_t_val, svfloat16_t_val); + svrintp_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_f32_x(svbool_t_val, svfloat32_t_val); + svrintp_f32_z(svbool_t_val, svfloat32_t_val); + svrintp_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_f64_x(svbool_t_val, svfloat64_t_val); + svrintp_f64_z(svbool_t_val, svfloat64_t_val); + svrintp_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintp_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintp_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintp_x(svbool_t_val, svfloat16_t_val); + svrintp_x(svbool_t_val, svfloat32_t_val); + svrintp_x(svbool_t_val, svfloat64_t_val); + svrintp_z(svbool_t_val, svfloat16_t_val); + svrintp_z(svbool_t_val, svfloat32_t_val); + svrintp_z(svbool_t_val, svfloat64_t_val); + svrintx_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_f16_x(svbool_t_val, svfloat16_t_val); + svrintx_f16_z(svbool_t_val, svfloat16_t_val); + svrintx_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_f32_x(svbool_t_val, svfloat32_t_val); + svrintx_f32_z(svbool_t_val, svfloat32_t_val); + svrintx_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_f64_x(svbool_t_val, svfloat64_t_val); + svrintx_f64_z(svbool_t_val, svfloat64_t_val); + svrintx_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintx_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintx_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintx_x(svbool_t_val, svfloat16_t_val); + svrintx_x(svbool_t_val, svfloat32_t_val); + svrintx_x(svbool_t_val, svfloat64_t_val); + svrintx_z(svbool_t_val, svfloat16_t_val); + svrintx_z(svbool_t_val, svfloat32_t_val); + svrintx_z(svbool_t_val, svfloat64_t_val); + svrintz_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_f16_x(svbool_t_val, svfloat16_t_val); + svrintz_f16_z(svbool_t_val, svfloat16_t_val); + svrintz_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_f32_x(svbool_t_val, svfloat32_t_val); + svrintz_f32_z(svbool_t_val, svfloat32_t_val); + svrintz_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_f64_x(svbool_t_val, svfloat64_t_val); + svrintz_f64_z(svbool_t_val, svfloat64_t_val); + svrintz_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svrintz_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svrintz_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svrintz_x(svbool_t_val, svfloat16_t_val); + svrintz_x(svbool_t_val, svfloat32_t_val); + svrintz_x(svbool_t_val, svfloat64_t_val); + svrintz_z(svbool_t_val, svfloat16_t_val); + svrintz_z(svbool_t_val, svfloat32_t_val); + svrintz_z(svbool_t_val, svfloat64_t_val); + svrsqrte(svfloat16_t_val); + svrsqrte(svfloat32_t_val); + svrsqrte(svfloat64_t_val); + svrsqrte_f16(svfloat16_t_val); + svrsqrte_f32(svfloat32_t_val); + svrsqrte_f64(svfloat64_t_val); + svrsqrts(svfloat16_t_val, svfloat16_t_val); + svrsqrts(svfloat32_t_val, svfloat32_t_val); + svrsqrts(svfloat64_t_val, svfloat64_t_val); + svrsqrts_f16(svfloat16_t_val, svfloat16_t_val); + svrsqrts_f32(svfloat32_t_val, svfloat32_t_val); + svrsqrts_f64(svfloat64_t_val, svfloat64_t_val); + svscale_f16_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f16_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_f32_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f32_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_f64_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_f64_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_m(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_m(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_m(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_n_f16_m(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f16_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_n_f32_m(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f32_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_n_f64_m(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_n_f64_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_x(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_x(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_x(svbool_t_val, svfloat64_t_val, svint64_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, int16_t_val); + svscale_z(svbool_t_val, svfloat16_t_val, svint16_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, int32_t_val); + svscale_z(svbool_t_val, svfloat32_t_val, svint32_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, int64_t_val); + svscale_z(svbool_t_val, svfloat64_t_val, svint64_t_val); + svsel(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel(svbool_t_val, svbool_t_val, svbool_t_val); + svsel(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel(svbool_t_val, svint8_t_val, svint8_t_val); + svsel(svbool_t_val, svint16_t_val, svint16_t_val); + svsel(svbool_t_val, svint32_t_val, svint32_t_val); + svsel(svbool_t_val, svint64_t_val, svint64_t_val); + svsel(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsel_b(svbool_t_val, svbool_t_val, svbool_t_val); + svsel_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsel_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsel_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsel_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsel_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsel_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsel_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsel_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsel_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsel_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsel_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsel_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svset2(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2(svint8x2_t_val, 1, svint8_t_val); + svset2(svint16x2_t_val, 1, svint16_t_val); + svset2(svint32x2_t_val, 1, svint32_t_val); + svset2(svint64x2_t_val, 1, svint64_t_val); + svset2(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2(svuint8x2_t_val, 1, svuint8_t_val); + svset2(svuint16x2_t_val, 1, svuint16_t_val); + svset2(svuint32x2_t_val, 1, svuint32_t_val); + svset2(svuint64x2_t_val, 1, svuint64_t_val); + svset2_bf16(svbfloat16x2_t_val, 1, svbfloat16_t_val); + svset2_f16(svfloat16x2_t_val, 1, svfloat16_t_val); + svset2_f32(svfloat32x2_t_val, 1, svfloat32_t_val); + svset2_f64(svfloat64x2_t_val, 1, svfloat64_t_val); + svset2_mf8(svmfloat8x2_t_val, 1, svmfloat8_t_val); + svset2_s8(svint8x2_t_val, 1, svint8_t_val); + svset2_s16(svint16x2_t_val, 1, svint16_t_val); + svset2_s32(svint32x2_t_val, 1, svint32_t_val); + svset2_s64(svint64x2_t_val, 1, svint64_t_val); + svset2_u8(svuint8x2_t_val, 1, svuint8_t_val); + svset2_u16(svuint16x2_t_val, 1, svuint16_t_val); + svset2_u32(svuint32x2_t_val, 1, svuint32_t_val); + svset2_u64(svuint64x2_t_val, 1, svuint64_t_val); + svset3(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3(svint8x3_t_val, 2, svint8_t_val); + svset3(svint16x3_t_val, 2, svint16_t_val); + svset3(svint32x3_t_val, 2, svint32_t_val); + svset3(svint64x3_t_val, 2, svint64_t_val); + svset3(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3(svuint8x3_t_val, 2, svuint8_t_val); + svset3(svuint16x3_t_val, 2, svuint16_t_val); + svset3(svuint32x3_t_val, 2, svuint32_t_val); + svset3(svuint64x3_t_val, 2, svuint64_t_val); + svset3_bf16(svbfloat16x3_t_val, 2, svbfloat16_t_val); + svset3_f16(svfloat16x3_t_val, 2, svfloat16_t_val); + svset3_f32(svfloat32x3_t_val, 2, svfloat32_t_val); + svset3_f64(svfloat64x3_t_val, 2, svfloat64_t_val); + svset3_mf8(svmfloat8x3_t_val, 2, svmfloat8_t_val); + svset3_s8(svint8x3_t_val, 2, svint8_t_val); + svset3_s16(svint16x3_t_val, 2, svint16_t_val); + svset3_s32(svint32x3_t_val, 2, svint32_t_val); + svset3_s64(svint64x3_t_val, 2, svint64_t_val); + svset3_u8(svuint8x3_t_val, 2, svuint8_t_val); + svset3_u16(svuint16x3_t_val, 2, svuint16_t_val); + svset3_u32(svuint32x3_t_val, 2, svuint32_t_val); + svset3_u64(svuint64x3_t_val, 2, svuint64_t_val); + svset4(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4(svint8x4_t_val, 2, svint8_t_val); + svset4(svint16x4_t_val, 2, svint16_t_val); + svset4(svint32x4_t_val, 2, svint32_t_val); + svset4(svint64x4_t_val, 2, svint64_t_val); + svset4(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4(svuint8x4_t_val, 2, svuint8_t_val); + svset4(svuint16x4_t_val, 2, svuint16_t_val); + svset4(svuint32x4_t_val, 2, svuint32_t_val); + svset4(svuint64x4_t_val, 2, svuint64_t_val); + svset4_bf16(svbfloat16x4_t_val, 2, svbfloat16_t_val); + svset4_f16(svfloat16x4_t_val, 2, svfloat16_t_val); + svset4_f32(svfloat32x4_t_val, 2, svfloat32_t_val); + svset4_f64(svfloat64x4_t_val, 2, svfloat64_t_val); + svset4_mf8(svmfloat8x4_t_val, 2, svmfloat8_t_val); + svset4_s8(svint8x4_t_val, 2, svint8_t_val); + svset4_s16(svint16x4_t_val, 2, svint16_t_val); + svset4_s32(svint32x4_t_val, 2, svint32_t_val); + svset4_s64(svint64x4_t_val, 2, svint64_t_val); + svset4_u8(svuint8x4_t_val, 2, svuint8_t_val); + svset4_u16(svuint16x4_t_val, 2, svuint16_t_val); + svset4_u32(svuint32x4_t_val, 2, svuint32_t_val); + svset4_u64(svuint64x4_t_val, 2, svuint64_t_val); + svsplice(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsplice_bf16(svbool_t_val, svbfloat16_t_val, svbfloat16_t_val); + svsplice_f16(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsplice_f32(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsplice_f64(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsplice_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svsplice_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svsplice_s32(svbool_t_val, svint32_t_val, svint32_t_val); + svsplice_s64(svbool_t_val, svint64_t_val, svint64_t_val); + svsplice_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsplice_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsplice_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsplice_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsqrt_f16_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_f16_x(svbool_t_val, svfloat16_t_val); + svsqrt_f16_z(svbool_t_val, svfloat16_t_val); + svsqrt_f32_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_f32_x(svbool_t_val, svfloat32_t_val); + svsqrt_f32_z(svbool_t_val, svfloat32_t_val); + svsqrt_f64_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_f64_x(svbool_t_val, svfloat64_t_val); + svsqrt_f64_z(svbool_t_val, svfloat64_t_val); + svsqrt_m(svfloat16_t_val, svbool_t_val, svfloat16_t_val); + svsqrt_m(svfloat32_t_val, svbool_t_val, svfloat32_t_val); + svsqrt_m(svfloat64_t_val, svbool_t_val, svfloat64_t_val); + svsqrt_x(svbool_t_val, svfloat16_t_val); + svsqrt_x(svbool_t_val, svfloat32_t_val); + svsqrt_x(svbool_t_val, svfloat64_t_val); + svsqrt_z(svbool_t_val, svfloat16_t_val); + svsqrt_z(svbool_t_val, svfloat32_t_val); + svsqrt_z(svbool_t_val, svfloat64_t_val); + svst1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svst1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svst1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svst1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svst1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svst1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svst1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svst1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svst1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svst1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svst1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svst1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svst1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svst1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svst1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_s16(svbool_t_val, int8_t_ptr_val, svint16_t_val); + svst1b_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svst1b_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svst1b_u16(svbool_t_val, uint8_t_ptr_val, svuint16_t_val); + svst1b_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svst1b_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1b_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val, svint16_t_val); + svst1b_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val, svint32_t_val); + svst1b_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val, svint64_t_val); + svst1b_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint16_t_val); + svst1b_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint32_t_val); + svst1b_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svst1h_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svst1h_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svst1h_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1h_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val, svint32_t_val); + svst1h_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val, svint64_t_val); + svst1h_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint32_t_val); + svst1h_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svst1w_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svst1w_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst1w_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val, svint64_t_val); + svst1w_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint64_t_val); + svst2(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x2_t_val); + svst2_f16(svbool_t_val, float16_t_ptr_val, svfloat16x2_t_val); + svst2_f32(svbool_t_val, float32_t_ptr_val, svfloat32x2_t_val); + svst2_f64(svbool_t_val, float64_t_ptr_val, svfloat64x2_t_val); + svst2_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x2_t_val); + svst2_s8(svbool_t_val, int8_t_ptr_val, svint8x2_t_val); + svst2_s16(svbool_t_val, int16_t_ptr_val, svint16x2_t_val); + svst2_s32(svbool_t_val, int32_t_ptr_val, svint32x2_t_val); + svst2_s64(svbool_t_val, int64_t_ptr_val, svint64x2_t_val); + svst2_u8(svbool_t_val, uint8_t_ptr_val, svuint8x2_t_val); + svst2_u16(svbool_t_val, uint16_t_ptr_val, svuint16x2_t_val); + svst2_u32(svbool_t_val, uint32_t_ptr_val, svuint32x2_t_val); + svst2_u64(svbool_t_val, uint64_t_ptr_val, svuint64x2_t_val); + svst2_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst2_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x2_t_val); + svst2_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x2_t_val); + svst2_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x2_t_val); + svst2_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x2_t_val); + svst2_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x2_t_val); + svst2_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x2_t_val); + svst2_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x2_t_val); + svst2_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x2_t_val); + svst2_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x2_t_val); + svst2_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x2_t_val); + svst2_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x2_t_val); + svst2_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x2_t_val); + svst2_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x2_t_val); + svst3(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x3_t_val); + svst3_f16(svbool_t_val, float16_t_ptr_val, svfloat16x3_t_val); + svst3_f32(svbool_t_val, float32_t_ptr_val, svfloat32x3_t_val); + svst3_f64(svbool_t_val, float64_t_ptr_val, svfloat64x3_t_val); + svst3_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x3_t_val); + svst3_s8(svbool_t_val, int8_t_ptr_val, svint8x3_t_val); + svst3_s16(svbool_t_val, int16_t_ptr_val, svint16x3_t_val); + svst3_s32(svbool_t_val, int32_t_ptr_val, svint32x3_t_val); + svst3_s64(svbool_t_val, int64_t_ptr_val, svint64x3_t_val); + svst3_u8(svbool_t_val, uint8_t_ptr_val, svuint8x3_t_val); + svst3_u16(svbool_t_val, uint16_t_ptr_val, svuint16x3_t_val); + svst3_u32(svbool_t_val, uint32_t_ptr_val, svuint32x3_t_val); + svst3_u64(svbool_t_val, uint64_t_ptr_val, svuint64x3_t_val); + svst3_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst3_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x3_t_val); + svst3_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x3_t_val); + svst3_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x3_t_val); + svst3_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x3_t_val); + svst3_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x3_t_val); + svst3_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x3_t_val); + svst3_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x3_t_val); + svst3_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x3_t_val); + svst3_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x3_t_val); + svst3_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x3_t_val); + svst3_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x3_t_val); + svst3_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x3_t_val); + svst3_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x3_t_val); + svst4(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16x4_t_val); + svst4_f16(svbool_t_val, float16_t_ptr_val, svfloat16x4_t_val); + svst4_f32(svbool_t_val, float32_t_ptr_val, svfloat32x4_t_val); + svst4_f64(svbool_t_val, float64_t_ptr_val, svfloat64x4_t_val); + svst4_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8x4_t_val); + svst4_s8(svbool_t_val, int8_t_ptr_val, svint8x4_t_val); + svst4_s16(svbool_t_val, int16_t_ptr_val, svint16x4_t_val); + svst4_s32(svbool_t_val, int32_t_ptr_val, svint32x4_t_val); + svst4_s64(svbool_t_val, int64_t_ptr_val, svint64x4_t_val); + svst4_u8(svbool_t_val, uint8_t_ptr_val, svuint8x4_t_val); + svst4_u16(svbool_t_val, uint16_t_ptr_val, svuint16x4_t_val); + svst4_u32(svbool_t_val, uint32_t_ptr_val, svuint32x4_t_val); + svst4_u64(svbool_t_val, uint64_t_ptr_val, svuint64x4_t_val); + svst4_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svst4_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16x4_t_val); + svst4_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16x4_t_val); + svst4_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32x4_t_val); + svst4_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64x4_t_val); + svst4_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8x4_t_val); + svst4_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8x4_t_val); + svst4_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16x4_t_val); + svst4_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32x4_t_val); + svst4_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64x4_t_val); + svst4_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8x4_t_val); + svst4_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16x4_t_val); + svst4_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32x4_t_val); + svst4_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64x4_t_val); + svstnt1(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_bf16(svbool_t_val, bfloat16_t_ptr_val, svbfloat16_t_val); + svstnt1_f16(svbool_t_val, float16_t_ptr_val, svfloat16_t_val); + svstnt1_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svstnt1_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svstnt1_mf8(svbool_t_val, mfloat8_t_ptr_val, svmfloat8_t_val); + svstnt1_s8(svbool_t_val, int8_t_ptr_val, svint8_t_val); + svstnt1_s16(svbool_t_val, int16_t_ptr_val, svint16_t_val); + svstnt1_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svstnt1_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svstnt1_u8(svbool_t_val, uint8_t_ptr_val, svuint8_t_val); + svstnt1_u16(svbool_t_val, uint16_t_ptr_val, svuint16_t_val); + svstnt1_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svstnt1_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svstnt1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svstnt1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val, svbfloat16_t_val); + svstnt1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val, svfloat16_t_val); + svstnt1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svstnt1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svstnt1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val, svmfloat8_t_val); + svstnt1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val, svint8_t_val); + svstnt1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val, svint16_t_val); + svstnt1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svstnt1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svstnt1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val, svuint8_t_val); + svstnt1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val, svuint16_t_val); + svstnt1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svstnt1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svsub_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_x(svbool_t_val, svint8_t_val, int8_t_val); + svsub_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_x(svbool_t_val, svint16_t_val, int16_t_val); + svsub_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_x(svbool_t_val, svint32_t_val, int32_t_val); + svsub_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_x(svbool_t_val, svint64_t_val, int64_t_val); + svsub_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsub_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsub_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsub_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsub_z(svbool_t_val, svint8_t_val, int8_t_val); + svsub_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsub_z(svbool_t_val, svint16_t_val, int16_t_val); + svsub_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsub_z(svbool_t_val, svint32_t_val, int32_t_val); + svsub_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsub_z(svbool_t_val, svint64_t_val, int64_t_val); + svsub_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsub_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsub_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsub_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsub_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsub_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsub_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsub_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsub_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_f16_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f16_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_f32_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f32_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_f64_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_f64_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_m(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_m(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_m(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_f16_m(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f16_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_n_f32_m(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f32_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_n_f64_m(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_f64_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_n_s8_m(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s8_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_n_s16_m(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s16_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_n_s32_m(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s32_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_n_s64_m(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_s64_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_n_u8_m(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u8_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_n_u16_m(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u16_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_n_u32_m(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u32_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_n_u64_m(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_n_u64_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_s8_m(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s8_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_s16_m(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s16_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_s32_m(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_s64_m(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_u8_m(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u8_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_u16_m(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u16_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_u32_m(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_u64_m(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_x(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_x(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_x(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_x(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_x(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_x(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_x(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_x(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_x(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_x(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_x(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_x(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_x(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_x(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_x(svbool_t_val, svuint64_t_val, uint64_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, float16_t_val); + svsubr_z(svbool_t_val, svfloat16_t_val, svfloat16_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, float32_t_val); + svsubr_z(svbool_t_val, svfloat32_t_val, svfloat32_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, float64_t_val); + svsubr_z(svbool_t_val, svfloat64_t_val, svfloat64_t_val); + svsubr_z(svbool_t_val, svint8_t_val, int8_t_val); + svsubr_z(svbool_t_val, svint8_t_val, svint8_t_val); + svsubr_z(svbool_t_val, svint16_t_val, int16_t_val); + svsubr_z(svbool_t_val, svint16_t_val, svint16_t_val); + svsubr_z(svbool_t_val, svint32_t_val, int32_t_val); + svsubr_z(svbool_t_val, svint32_t_val, svint32_t_val); + svsubr_z(svbool_t_val, svint64_t_val, int64_t_val); + svsubr_z(svbool_t_val, svint64_t_val, svint64_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, svuint8_t_val); + svsubr_z(svbool_t_val, svuint8_t_val, uint8_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, svuint16_t_val); + svsubr_z(svbool_t_val, svuint16_t_val, uint16_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svsubr_z(svbool_t_val, svuint32_t_val, uint32_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svsubr_z(svbool_t_val, svuint64_t_val, uint64_t_val); + svtbl(svbfloat16_t_val, svuint16_t_val); + svtbl(svfloat16_t_val, svuint16_t_val); + svtbl(svfloat32_t_val, svuint32_t_val); + svtbl(svfloat64_t_val, svuint64_t_val); + svtbl(svint8_t_val, svuint8_t_val); + svtbl(svint16_t_val, svuint16_t_val); + svtbl(svint32_t_val, svuint32_t_val); + svtbl(svint64_t_val, svuint64_t_val); + svtbl(svuint8_t_val, svuint8_t_val); + svtbl(svuint16_t_val, svuint16_t_val); + svtbl(svuint32_t_val, svuint32_t_val); + svtbl(svuint64_t_val, svuint64_t_val); + svtbl_bf16(svbfloat16_t_val, svuint16_t_val); + svtbl_f16(svfloat16_t_val, svuint16_t_val); + svtbl_f32(svfloat32_t_val, svuint32_t_val); + svtbl_f64(svfloat64_t_val, svuint64_t_val); + svtbl_s8(svint8_t_val, svuint8_t_val); + svtbl_s16(svint16_t_val, svuint16_t_val); + svtbl_s32(svint32_t_val, svuint32_t_val); + svtbl_s64(svint64_t_val, svuint64_t_val); + svtbl_u8(svuint8_t_val, svuint8_t_val); + svtbl_u16(svuint16_t_val, svuint16_t_val); + svtbl_u32(svuint32_t_val, svuint32_t_val); + svtbl_u64(svuint64_t_val, svuint64_t_val); + svtrn1(svbfloat16_t_val, svbfloat16_t_val); + svtrn1(svfloat16_t_val, svfloat16_t_val); + svtrn1(svfloat32_t_val, svfloat32_t_val); + svtrn1(svfloat64_t_val, svfloat64_t_val); + svtrn1(svint8_t_val, svint8_t_val); + svtrn1(svint16_t_val, svint16_t_val); + svtrn1(svint32_t_val, svint32_t_val); + svtrn1(svint64_t_val, svint64_t_val); + svtrn1(svuint8_t_val, svuint8_t_val); + svtrn1(svuint16_t_val, svuint16_t_val); + svtrn1(svuint32_t_val, svuint32_t_val); + svtrn1(svuint64_t_val, svuint64_t_val); + svtrn1_b8(svbool_t_val, svbool_t_val); + svtrn1_b16(svbool_t_val, svbool_t_val); + svtrn1_b32(svbool_t_val, svbool_t_val); + svtrn1_b64(svbool_t_val, svbool_t_val); + svtrn1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn1_f16(svfloat16_t_val, svfloat16_t_val); + svtrn1_f32(svfloat32_t_val, svfloat32_t_val); + svtrn1_f64(svfloat64_t_val, svfloat64_t_val); + svtrn1_s8(svint8_t_val, svint8_t_val); + svtrn1_s16(svint16_t_val, svint16_t_val); + svtrn1_s32(svint32_t_val, svint32_t_val); + svtrn1_s64(svint64_t_val, svint64_t_val); + svtrn1_u8(svuint8_t_val, svuint8_t_val); + svtrn1_u16(svuint16_t_val, svuint16_t_val); + svtrn1_u32(svuint32_t_val, svuint32_t_val); + svtrn1_u64(svuint64_t_val, svuint64_t_val); + svtrn2(svbfloat16_t_val, svbfloat16_t_val); + svtrn2(svfloat16_t_val, svfloat16_t_val); + svtrn2(svfloat32_t_val, svfloat32_t_val); + svtrn2(svfloat64_t_val, svfloat64_t_val); + svtrn2(svint8_t_val, svint8_t_val); + svtrn2(svint16_t_val, svint16_t_val); + svtrn2(svint32_t_val, svint32_t_val); + svtrn2(svint64_t_val, svint64_t_val); + svtrn2(svuint8_t_val, svuint8_t_val); + svtrn2(svuint16_t_val, svuint16_t_val); + svtrn2(svuint32_t_val, svuint32_t_val); + svtrn2(svuint64_t_val, svuint64_t_val); + svtrn2_b8(svbool_t_val, svbool_t_val); + svtrn2_b16(svbool_t_val, svbool_t_val); + svtrn2_b32(svbool_t_val, svbool_t_val); + svtrn2_b64(svbool_t_val, svbool_t_val); + svtrn2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn2_f16(svfloat16_t_val, svfloat16_t_val); + svtrn2_f32(svfloat32_t_val, svfloat32_t_val); + svtrn2_f64(svfloat64_t_val, svfloat64_t_val); + svtrn2_s8(svint8_t_val, svint8_t_val); + svtrn2_s16(svint16_t_val, svint16_t_val); + svtrn2_s32(svint32_t_val, svint32_t_val); + svtrn2_s64(svint64_t_val, svint64_t_val); + svtrn2_u8(svuint8_t_val, svuint8_t_val); + svtrn2_u16(svuint16_t_val, svuint16_t_val); + svtrn2_u32(svuint32_t_val, svuint32_t_val); + svtrn2_u64(svuint64_t_val, svuint64_t_val); + svundef2_bf16(); + svundef2_f16(); + svundef2_f32(); + svundef2_f64(); + svundef2_mf8(); + svundef2_s8(); + svundef2_s16(); + svundef2_s32(); + svundef2_s64(); + svundef2_u8(); + svundef2_u16(); + svundef2_u32(); + svundef2_u64(); + svundef3_bf16(); + svundef3_f16(); + svundef3_f32(); + svundef3_f64(); + svundef3_mf8(); + svundef3_s8(); + svundef3_s16(); + svundef3_s32(); + svundef3_s64(); + svundef3_u8(); + svundef3_u16(); + svundef3_u32(); + svundef3_u64(); + svundef4_bf16(); + svundef4_f16(); + svundef4_f32(); + svundef4_f64(); + svundef4_mf8(); + svundef4_s8(); + svundef4_s16(); + svundef4_s32(); + svundef4_s64(); + svundef4_u8(); + svundef4_u16(); + svundef4_u32(); + svundef4_u64(); + svundef_bf16(); + svundef_f16(); + svundef_f32(); + svundef_f64(); + svundef_mf8(); + svundef_s8(); + svundef_s16(); + svundef_s32(); + svundef_s64(); + svundef_u8(); + svundef_u16(); + svundef_u32(); + svundef_u64(); + svunpkhi(svbool_t_val); + svunpkhi(svint8_t_val); + svunpkhi(svint16_t_val); + svunpkhi(svint32_t_val); + svunpkhi(svuint8_t_val); + svunpkhi(svuint16_t_val); + svunpkhi(svuint32_t_val); + svunpkhi_b(svbool_t_val); + svunpkhi_s16(svint8_t_val); + svunpkhi_s32(svint16_t_val); + svunpkhi_s64(svint32_t_val); + svunpkhi_u16(svuint8_t_val); + svunpkhi_u32(svuint16_t_val); + svunpkhi_u64(svuint32_t_val); + svunpklo(svbool_t_val); + svunpklo(svint8_t_val); + svunpklo(svint16_t_val); + svunpklo(svint32_t_val); + svunpklo(svuint8_t_val); + svunpklo(svuint16_t_val); + svunpklo(svuint32_t_val); + svunpklo_b(svbool_t_val); + svunpklo_s16(svint8_t_val); + svunpklo_s32(svint16_t_val); + svunpklo_s64(svint32_t_val); + svunpklo_u16(svuint8_t_val); + svunpklo_u32(svuint16_t_val); + svunpklo_u64(svuint32_t_val); + svuzp1(svbfloat16_t_val, svbfloat16_t_val); + svuzp1(svfloat16_t_val, svfloat16_t_val); + svuzp1(svfloat32_t_val, svfloat32_t_val); + svuzp1(svfloat64_t_val, svfloat64_t_val); + svuzp1(svint8_t_val, svint8_t_val); + svuzp1(svint16_t_val, svint16_t_val); + svuzp1(svint32_t_val, svint32_t_val); + svuzp1(svint64_t_val, svint64_t_val); + svuzp1(svuint8_t_val, svuint8_t_val); + svuzp1(svuint16_t_val, svuint16_t_val); + svuzp1(svuint32_t_val, svuint32_t_val); + svuzp1(svuint64_t_val, svuint64_t_val); + svuzp1_b8(svbool_t_val, svbool_t_val); + svuzp1_b16(svbool_t_val, svbool_t_val); + svuzp1_b32(svbool_t_val, svbool_t_val); + svuzp1_b64(svbool_t_val, svbool_t_val); + svuzp1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp1_f16(svfloat16_t_val, svfloat16_t_val); + svuzp1_f32(svfloat32_t_val, svfloat32_t_val); + svuzp1_f64(svfloat64_t_val, svfloat64_t_val); + svuzp1_s8(svint8_t_val, svint8_t_val); + svuzp1_s16(svint16_t_val, svint16_t_val); + svuzp1_s32(svint32_t_val, svint32_t_val); + svuzp1_s64(svint64_t_val, svint64_t_val); + svuzp1_u8(svuint8_t_val, svuint8_t_val); + svuzp1_u16(svuint16_t_val, svuint16_t_val); + svuzp1_u32(svuint32_t_val, svuint32_t_val); + svuzp1_u64(svuint64_t_val, svuint64_t_val); + svuzp2(svbfloat16_t_val, svbfloat16_t_val); + svuzp2(svfloat16_t_val, svfloat16_t_val); + svuzp2(svfloat32_t_val, svfloat32_t_val); + svuzp2(svfloat64_t_val, svfloat64_t_val); + svuzp2(svint8_t_val, svint8_t_val); + svuzp2(svint16_t_val, svint16_t_val); + svuzp2(svint32_t_val, svint32_t_val); + svuzp2(svint64_t_val, svint64_t_val); + svuzp2(svuint8_t_val, svuint8_t_val); + svuzp2(svuint16_t_val, svuint16_t_val); + svuzp2(svuint32_t_val, svuint32_t_val); + svuzp2(svuint64_t_val, svuint64_t_val); + svuzp2_b8(svbool_t_val, svbool_t_val); + svuzp2_b16(svbool_t_val, svbool_t_val); + svuzp2_b32(svbool_t_val, svbool_t_val); + svuzp2_b64(svbool_t_val, svbool_t_val); + svuzp2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp2_f16(svfloat16_t_val, svfloat16_t_val); + svuzp2_f32(svfloat32_t_val, svfloat32_t_val); + svuzp2_f64(svfloat64_t_val, svfloat64_t_val); + svuzp2_s8(svint8_t_val, svint8_t_val); + svuzp2_s16(svint16_t_val, svint16_t_val); + svuzp2_s32(svint32_t_val, svint32_t_val); + svuzp2_s64(svint64_t_val, svint64_t_val); + svuzp2_u8(svuint8_t_val, svuint8_t_val); + svuzp2_u16(svuint16_t_val, svuint16_t_val); + svuzp2_u32(svuint32_t_val, svuint32_t_val); + svuzp2_u64(svuint64_t_val, svuint64_t_val); + svwhilele_b8(int32_t_val, int32_t_val); + svwhilele_b8(int64_t_val, int64_t_val); + svwhilele_b8(uint32_t_val, uint32_t_val); + svwhilele_b8(uint64_t_val, uint64_t_val); + svwhilele_b8_s32(int32_t_val, int32_t_val); + svwhilele_b8_s64(int64_t_val, int64_t_val); + svwhilele_b8_u32(uint32_t_val, uint32_t_val); + svwhilele_b8_u64(uint64_t_val, uint64_t_val); + svwhilele_b16(int32_t_val, int32_t_val); + svwhilele_b16(int64_t_val, int64_t_val); + svwhilele_b16(uint32_t_val, uint32_t_val); + svwhilele_b16(uint64_t_val, uint64_t_val); + svwhilele_b16_s32(int32_t_val, int32_t_val); + svwhilele_b16_s64(int64_t_val, int64_t_val); + svwhilele_b16_u32(uint32_t_val, uint32_t_val); + svwhilele_b16_u64(uint64_t_val, uint64_t_val); + svwhilele_b32(int32_t_val, int32_t_val); + svwhilele_b32(int64_t_val, int64_t_val); + svwhilele_b32(uint32_t_val, uint32_t_val); + svwhilele_b32(uint64_t_val, uint64_t_val); + svwhilele_b32_s32(int32_t_val, int32_t_val); + svwhilele_b32_s64(int64_t_val, int64_t_val); + svwhilele_b32_u32(uint32_t_val, uint32_t_val); + svwhilele_b32_u64(uint64_t_val, uint64_t_val); + svwhilele_b64(int32_t_val, int32_t_val); + svwhilele_b64(int64_t_val, int64_t_val); + svwhilele_b64(uint32_t_val, uint32_t_val); + svwhilele_b64(uint64_t_val, uint64_t_val); + svwhilele_b64_s32(int32_t_val, int32_t_val); + svwhilele_b64_s64(int64_t_val, int64_t_val); + svwhilele_b64_u32(uint32_t_val, uint32_t_val); + svwhilele_b64_u64(uint64_t_val, uint64_t_val); + svwhilelt_b8(int32_t_val, int32_t_val); + svwhilelt_b8(int64_t_val, int64_t_val); + svwhilelt_b8(uint32_t_val, uint32_t_val); + svwhilelt_b8(uint64_t_val, uint64_t_val); + svwhilelt_b8_s32(int32_t_val, int32_t_val); + svwhilelt_b8_s64(int64_t_val, int64_t_val); + svwhilelt_b8_u32(uint32_t_val, uint32_t_val); + svwhilelt_b8_u64(uint64_t_val, uint64_t_val); + svwhilelt_b16(int32_t_val, int32_t_val); + svwhilelt_b16(int64_t_val, int64_t_val); + svwhilelt_b16(uint32_t_val, uint32_t_val); + svwhilelt_b16(uint64_t_val, uint64_t_val); + svwhilelt_b16_s32(int32_t_val, int32_t_val); + svwhilelt_b16_s64(int64_t_val, int64_t_val); + svwhilelt_b16_u32(uint32_t_val, uint32_t_val); + svwhilelt_b16_u64(uint64_t_val, uint64_t_val); + svwhilelt_b32(int32_t_val, int32_t_val); + svwhilelt_b32(int64_t_val, int64_t_val); + svwhilelt_b32(uint32_t_val, uint32_t_val); + svwhilelt_b32(uint64_t_val, uint64_t_val); + svwhilelt_b32_s32(int32_t_val, int32_t_val); + svwhilelt_b32_s64(int64_t_val, int64_t_val); + svwhilelt_b32_u32(uint32_t_val, uint32_t_val); + svwhilelt_b32_u64(uint64_t_val, uint64_t_val); + svwhilelt_b64(int32_t_val, int32_t_val); + svwhilelt_b64(int64_t_val, int64_t_val); + svwhilelt_b64(uint32_t_val, uint32_t_val); + svwhilelt_b64(uint64_t_val, uint64_t_val); + svwhilelt_b64_s32(int32_t_val, int32_t_val); + svwhilelt_b64_s64(int64_t_val, int64_t_val); + svwhilelt_b64_u32(uint32_t_val, uint32_t_val); + svwhilelt_b64_u64(uint64_t_val, uint64_t_val); + svzip1(svbfloat16_t_val, svbfloat16_t_val); + svzip1(svfloat16_t_val, svfloat16_t_val); + svzip1(svfloat32_t_val, svfloat32_t_val); + svzip1(svfloat64_t_val, svfloat64_t_val); + svzip1(svint8_t_val, svint8_t_val); + svzip1(svint16_t_val, svint16_t_val); + svzip1(svint32_t_val, svint32_t_val); + svzip1(svint64_t_val, svint64_t_val); + svzip1(svuint8_t_val, svuint8_t_val); + svzip1(svuint16_t_val, svuint16_t_val); + svzip1(svuint32_t_val, svuint32_t_val); + svzip1(svuint64_t_val, svuint64_t_val); + svzip1_b8(svbool_t_val, svbool_t_val); + svzip1_b16(svbool_t_val, svbool_t_val); + svzip1_b32(svbool_t_val, svbool_t_val); + svzip1_b64(svbool_t_val, svbool_t_val); + svzip1_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip1_f16(svfloat16_t_val, svfloat16_t_val); + svzip1_f32(svfloat32_t_val, svfloat32_t_val); + svzip1_f64(svfloat64_t_val, svfloat64_t_val); + svzip1_s8(svint8_t_val, svint8_t_val); + svzip1_s16(svint16_t_val, svint16_t_val); + svzip1_s32(svint32_t_val, svint32_t_val); + svzip1_s64(svint64_t_val, svint64_t_val); + svzip1_u8(svuint8_t_val, svuint8_t_val); + svzip1_u16(svuint16_t_val, svuint16_t_val); + svzip1_u32(svuint32_t_val, svuint32_t_val); + svzip1_u64(svuint64_t_val, svuint64_t_val); + svzip2(svbfloat16_t_val, svbfloat16_t_val); + svzip2(svfloat16_t_val, svfloat16_t_val); + svzip2(svfloat32_t_val, svfloat32_t_val); + svzip2(svfloat64_t_val, svfloat64_t_val); + svzip2(svint8_t_val, svint8_t_val); + svzip2(svint16_t_val, svint16_t_val); + svzip2(svint32_t_val, svint32_t_val); + svzip2(svint64_t_val, svint64_t_val); + svzip2(svuint8_t_val, svuint8_t_val); + svzip2(svuint16_t_val, svuint16_t_val); + svzip2(svuint32_t_val, svuint32_t_val); + svzip2(svuint64_t_val, svuint64_t_val); + svzip2_b8(svbool_t_val, svbool_t_val); + svzip2_b16(svbool_t_val, svbool_t_val); + svzip2_b32(svbool_t_val, svbool_t_val); + svzip2_b64(svbool_t_val, svbool_t_val); + svzip2_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip2_f16(svfloat16_t_val, svfloat16_t_val); + svzip2_f32(svfloat32_t_val, svfloat32_t_val); + svzip2_f64(svfloat64_t_val, svfloat64_t_val); + svzip2_s8(svint8_t_val, svint8_t_val); + svzip2_s16(svint16_t_val, svint16_t_val); + svzip2_s32(svint32_t_val, svint32_t_val); + svzip2_s64(svint64_t_val, svint64_t_val); + svzip2_u8(svuint8_t_val, svuint8_t_val); + svzip2_u16(svuint16_t_val, svuint16_t_val); + svzip2_u32(svuint32_t_val, svuint32_t_val); + svzip2_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2_AND_ssve-fexpa.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2_AND_ssve-fexpa.c new file mode 100644 index 0000000..c05c29e --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2_AND_ssve-fexpa.c @@ -0,0 +1,61 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +ssve-fexpa -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve" streaming_guard="sme,sme2,ssve-fexpa" flags="feature-dependent" + +void test(void) { + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + svexpa(svuint16_t_val); + svexpa(svuint32_t_val); + svexpa(svuint64_t_val); + svexpa_f16(svuint16_t_val); + svexpa_f32(svuint32_t_val); + svexpa_f64(svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f16(svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f32(svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f64(svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa(svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f16(svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f32(svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svexpa_f64(svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2p2.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2p2.c new file mode 100644 index 0000000..456f379 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve___sme_AND_sme2p2.c @@ -0,0 +1,103 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=guard +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2p2 -target-feature +sve -verify +// expected-no-diagnostics + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve" streaming_guard="sme,sme2p2" flags="feature-dependent" + +void test(void) { + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + svcompact(svbool_t_val, svfloat32_t_val); + svcompact(svbool_t_val, svfloat64_t_val); + svcompact(svbool_t_val, svint32_t_val); + svcompact(svbool_t_val, svint64_t_val); + svcompact(svbool_t_val, svuint32_t_val); + svcompact(svbool_t_val, svuint64_t_val); + svcompact_f32(svbool_t_val, svfloat32_t_val); + svcompact_f64(svbool_t_val, svfloat64_t_val); + svcompact_s32(svbool_t_val, svint32_t_val); + svcompact_s64(svbool_t_val, svint64_t_val); + svcompact_u32(svbool_t_val, svuint32_t_val); + svcompact_u64(svbool_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_f32(svbool_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_f64(svbool_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_s32(svbool_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_s64(svbool_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_u64(svbool_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_f32(svbool_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_f64(svbool_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_s32(svbool_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_s64(svbool_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svcompact_u64(svbool_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve.c new file mode 100644 index 0000000..58f1196 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve.c @@ -0,0 +1,5881 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve" streaming_guard="" flags="" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + void * void_ptr_val; + + svadda(svbool_t_val, float16_t_val, svfloat16_t_val); + svadda(svbool_t_val, float32_t_val, svfloat32_t_val); + svadda(svbool_t_val, float64_t_val, svfloat64_t_val); + svadda_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + svadda_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + svadda_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + svadrb_offset(svuint32_t_val, svint32_t_val); + svadrb_offset(svuint32_t_val, svuint32_t_val); + svadrb_offset(svuint64_t_val, svint64_t_val); + svadrb_offset(svuint64_t_val, svuint64_t_val); + svadrb_u32base_s32offset(svuint32_t_val, svint32_t_val); + svadrb_u32base_u32offset(svuint32_t_val, svuint32_t_val); + svadrb_u64base_s64offset(svuint64_t_val, svint64_t_val); + svadrb_u64base_u64offset(svuint64_t_val, svuint64_t_val); + svadrd_index(svuint32_t_val, svint32_t_val); + svadrd_index(svuint32_t_val, svuint32_t_val); + svadrd_index(svuint64_t_val, svint64_t_val); + svadrd_index(svuint64_t_val, svuint64_t_val); + svadrd_u32base_s32index(svuint32_t_val, svint32_t_val); + svadrd_u32base_u32index(svuint32_t_val, svuint32_t_val); + svadrd_u64base_s64index(svuint64_t_val, svint64_t_val); + svadrd_u64base_u64index(svuint64_t_val, svuint64_t_val); + svadrh_index(svuint32_t_val, svint32_t_val); + svadrh_index(svuint32_t_val, svuint32_t_val); + svadrh_index(svuint64_t_val, svint64_t_val); + svadrh_index(svuint64_t_val, svuint64_t_val); + svadrh_u32base_s32index(svuint32_t_val, svint32_t_val); + svadrh_u32base_u32index(svuint32_t_val, svuint32_t_val); + svadrh_u64base_s64index(svuint64_t_val, svint64_t_val); + svadrh_u64base_u64index(svuint64_t_val, svuint64_t_val); + svadrw_index(svuint32_t_val, svint32_t_val); + svadrw_index(svuint32_t_val, svuint32_t_val); + svadrw_index(svuint64_t_val, svint64_t_val); + svadrw_index(svuint64_t_val, svuint64_t_val); + svadrw_u32base_s32index(svuint32_t_val, svint32_t_val); + svadrw_u32base_u32index(svuint32_t_val, svuint32_t_val); + svadrw_u64base_s64index(svuint64_t_val, svint64_t_val); + svadrw_u64base_u64index(svuint64_t_val, svuint64_t_val); + svld1_gather_f32(svbool_t_val, svuint32_t_val); + svld1_gather_f64(svbool_t_val, svuint64_t_val); + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_s32(svbool_t_val, svuint32_t_val); + svld1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svld1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svld1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svld1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svld1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svld1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svld1_gather_s64(svbool_t_val, svuint64_t_val); + svld1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svld1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svld1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svld1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svld1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svld1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svld1_gather_u32(svbool_t_val, svuint32_t_val); + svld1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + svld1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svld1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svld1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svld1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svld1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svld1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svld1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svld1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svld1_gather_u64(svbool_t_val, svuint64_t_val); + svld1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + svld1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svld1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svld1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sb_gather_s32(svbool_t_val, svuint32_t_val); + svld1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svld1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svld1sb_gather_s64(svbool_t_val, svuint64_t_val); + svld1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svld1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svld1sb_gather_u32(svbool_t_val, svuint32_t_val); + svld1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svld1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svld1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svld1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svld1sb_gather_u64(svbool_t_val, svuint64_t_val); + svld1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_s32(svbool_t_val, svuint32_t_val); + svld1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svld1sh_gather_s64(svbool_t_val, svuint64_t_val); + svld1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svld1sh_gather_u32(svbool_t_val, svuint32_t_val); + svld1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svld1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svld1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svld1sh_gather_u64(svbool_t_val, svuint64_t_val); + svld1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_s64(svbool_t_val, svuint64_t_val); + svld1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svld1sw_gather_u64(svbool_t_val, svuint64_t_val); + svld1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svld1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svld1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1ub_gather_s32(svbool_t_val, svuint32_t_val); + svld1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svld1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svld1ub_gather_s64(svbool_t_val, svuint64_t_val); + svld1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svld1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svld1ub_gather_u32(svbool_t_val, svuint32_t_val); + svld1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svld1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svld1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svld1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svld1ub_gather_u64(svbool_t_val, svuint64_t_val); + svld1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_s32(svbool_t_val, svuint32_t_val); + svld1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svld1uh_gather_s64(svbool_t_val, svuint64_t_val); + svld1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svld1uh_gather_u32(svbool_t_val, svuint32_t_val); + svld1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svld1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svld1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svld1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svld1uh_gather_u64(svbool_t_val, svuint64_t_val); + svld1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_s64(svbool_t_val, svuint64_t_val); + svld1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svld1uw_gather_u64(svbool_t_val, svuint64_t_val); + svld1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1(svbool_t_val, bfloat16_t_ptr_val); + svldff1(svbool_t_val, float16_t_ptr_val); + svldff1(svbool_t_val, float32_t_ptr_val); + svldff1(svbool_t_val, float64_t_ptr_val); + svldff1(svbool_t_val, int8_t_ptr_val); + svldff1(svbool_t_val, int16_t_ptr_val); + svldff1(svbool_t_val, int32_t_ptr_val); + svldff1(svbool_t_val, int64_t_ptr_val); + svldff1(svbool_t_val, mfloat8_t_ptr_val); + svldff1(svbool_t_val, uint8_t_ptr_val); + svldff1(svbool_t_val, uint16_t_ptr_val); + svldff1(svbool_t_val, uint32_t_ptr_val); + svldff1(svbool_t_val, uint64_t_ptr_val); + svldff1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svldff1_f16(svbool_t_val, float16_t_ptr_val); + svldff1_f32(svbool_t_val, float32_t_ptr_val); + svldff1_f64(svbool_t_val, float64_t_ptr_val); + svldff1_gather_f32(svbool_t_val, svuint32_t_val); + svldff1_gather_f64(svbool_t_val, svuint64_t_val); + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldff1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldff1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_s32(svbool_t_val, svuint32_t_val); + svldff1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svldff1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svldff1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svldff1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + svldff1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svldff1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + svldff1_gather_s64(svbool_t_val, svuint64_t_val); + svldff1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldff1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldff1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldff1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldff1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldff1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldff1_gather_u32(svbool_t_val, svuint32_t_val); + svldff1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + svldff1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldff1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldff1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldff1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldff1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldff1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldff1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldff1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldff1_gather_u64(svbool_t_val, svuint64_t_val); + svldff1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + svldff1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldff1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldff1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldff1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldff1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldff1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldff1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svldff1_s8(svbool_t_val, int8_t_ptr_val); + svldff1_s16(svbool_t_val, int16_t_ptr_val); + svldff1_s32(svbool_t_val, int32_t_ptr_val); + svldff1_s64(svbool_t_val, int64_t_ptr_val); + svldff1_u8(svbool_t_val, uint8_t_ptr_val); + svldff1_u16(svbool_t_val, uint16_t_ptr_val); + svldff1_u32(svbool_t_val, uint32_t_ptr_val); + svldff1_u64(svbool_t_val, uint64_t_ptr_val); + svldff1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldff1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldff1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldff1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldff1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldff1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldff1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldff1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldff1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldff1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldff1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldff1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldff1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldff1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldff1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sb_gather_s32(svbool_t_val, svuint32_t_val); + svldff1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svldff1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + svldff1sb_gather_s64(svbool_t_val, svuint64_t_val); + svldff1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldff1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldff1sb_gather_u32(svbool_t_val, svuint32_t_val); + svldff1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldff1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldff1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldff1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldff1sb_gather_u64(svbool_t_val, svuint64_t_val); + svldff1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldff1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldff1sb_s16(svbool_t_val, int8_t_ptr_val); + svldff1sb_s32(svbool_t_val, int8_t_ptr_val); + svldff1sb_s64(svbool_t_val, int8_t_ptr_val); + svldff1sb_u16(svbool_t_val, int8_t_ptr_val); + svldff1sb_u32(svbool_t_val, int8_t_ptr_val); + svldff1sb_u64(svbool_t_val, int8_t_ptr_val); + svldff1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_s32(svbool_t_val, svuint32_t_val); + svldff1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + svldff1sh_gather_s64(svbool_t_val, svuint64_t_val); + svldff1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldff1sh_gather_u32(svbool_t_val, svuint32_t_val); + svldff1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldff1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldff1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldff1sh_gather_u64(svbool_t_val, svuint64_t_val); + svldff1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldff1sh_s32(svbool_t_val, int16_t_ptr_val); + svldff1sh_s64(svbool_t_val, int16_t_ptr_val); + svldff1sh_u32(svbool_t_val, int16_t_ptr_val); + svldff1sh_u64(svbool_t_val, int16_t_ptr_val); + svldff1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_s64(svbool_t_val, svuint64_t_val); + svldff1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldff1sw_gather_u64(svbool_t_val, svuint64_t_val); + svldff1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldff1sw_s64(svbool_t_val, int32_t_ptr_val); + svldff1sw_u64(svbool_t_val, int32_t_ptr_val); + svldff1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldff1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldff1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldff1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldff1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldff1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldff1ub_gather_s32(svbool_t_val, svuint32_t_val); + svldff1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svldff1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + svldff1ub_gather_s64(svbool_t_val, svuint64_t_val); + svldff1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldff1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldff1ub_gather_u32(svbool_t_val, svuint32_t_val); + svldff1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldff1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldff1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldff1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldff1ub_gather_u64(svbool_t_val, svuint64_t_val); + svldff1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldff1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldff1ub_s16(svbool_t_val, uint8_t_ptr_val); + svldff1ub_s32(svbool_t_val, uint8_t_ptr_val); + svldff1ub_s64(svbool_t_val, uint8_t_ptr_val); + svldff1ub_u16(svbool_t_val, uint8_t_ptr_val); + svldff1ub_u32(svbool_t_val, uint8_t_ptr_val); + svldff1ub_u64(svbool_t_val, uint8_t_ptr_val); + svldff1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldff1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_s32(svbool_t_val, svuint32_t_val); + svldff1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + svldff1uh_gather_s64(svbool_t_val, svuint64_t_val); + svldff1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldff1uh_gather_u32(svbool_t_val, svuint32_t_val); + svldff1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldff1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldff1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldff1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldff1uh_gather_u64(svbool_t_val, svuint64_t_val); + svldff1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldff1uh_s32(svbool_t_val, uint16_t_ptr_val); + svldff1uh_s64(svbool_t_val, uint16_t_ptr_val); + svldff1uh_u32(svbool_t_val, uint16_t_ptr_val); + svldff1uh_u64(svbool_t_val, uint16_t_ptr_val); + svldff1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldff1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_s64(svbool_t_val, svuint64_t_val); + svldff1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldff1uw_gather_u64(svbool_t_val, svuint64_t_val); + svldff1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldff1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldff1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldff1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldff1uw_s64(svbool_t_val, uint32_t_ptr_val); + svldff1uw_u64(svbool_t_val, uint32_t_ptr_val); + svldff1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldff1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnf1(svbool_t_val, bfloat16_t_ptr_val); + svldnf1(svbool_t_val, float16_t_ptr_val); + svldnf1(svbool_t_val, float32_t_ptr_val); + svldnf1(svbool_t_val, float64_t_ptr_val); + svldnf1(svbool_t_val, int8_t_ptr_val); + svldnf1(svbool_t_val, int16_t_ptr_val); + svldnf1(svbool_t_val, int32_t_ptr_val); + svldnf1(svbool_t_val, int64_t_ptr_val); + svldnf1(svbool_t_val, mfloat8_t_ptr_val); + svldnf1(svbool_t_val, uint8_t_ptr_val); + svldnf1(svbool_t_val, uint16_t_ptr_val); + svldnf1(svbool_t_val, uint32_t_ptr_val); + svldnf1(svbool_t_val, uint64_t_ptr_val); + svldnf1_bf16(svbool_t_val, bfloat16_t_ptr_val); + svldnf1_f16(svbool_t_val, float16_t_ptr_val); + svldnf1_f32(svbool_t_val, float32_t_ptr_val); + svldnf1_f64(svbool_t_val, float64_t_ptr_val); + svldnf1_mf8(svbool_t_val, mfloat8_t_ptr_val); + svldnf1_s8(svbool_t_val, int8_t_ptr_val); + svldnf1_s16(svbool_t_val, int16_t_ptr_val); + svldnf1_s32(svbool_t_val, int32_t_ptr_val); + svldnf1_s64(svbool_t_val, int64_t_ptr_val); + svldnf1_u8(svbool_t_val, uint8_t_ptr_val); + svldnf1_u16(svbool_t_val, uint16_t_ptr_val); + svldnf1_u32(svbool_t_val, uint32_t_ptr_val); + svldnf1_u64(svbool_t_val, uint64_t_ptr_val); + svldnf1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnf1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnf1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + svldnf1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + svldnf1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svldnf1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svldnf1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + svldnf1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnf1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svldnf1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnf1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svldnf1sb_s16(svbool_t_val, int8_t_ptr_val); + svldnf1sb_s32(svbool_t_val, int8_t_ptr_val); + svldnf1sb_s64(svbool_t_val, int8_t_ptr_val); + svldnf1sb_u16(svbool_t_val, int8_t_ptr_val); + svldnf1sb_u32(svbool_t_val, int8_t_ptr_val); + svldnf1sb_u64(svbool_t_val, int8_t_ptr_val); + svldnf1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + svldnf1sh_s32(svbool_t_val, int16_t_ptr_val); + svldnf1sh_s64(svbool_t_val, int16_t_ptr_val); + svldnf1sh_u32(svbool_t_val, int16_t_ptr_val); + svldnf1sh_u64(svbool_t_val, int16_t_ptr_val); + svldnf1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + svldnf1sw_s64(svbool_t_val, int32_t_ptr_val); + svldnf1sw_u64(svbool_t_val, int32_t_ptr_val); + svldnf1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnf1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + svldnf1ub_s16(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_s32(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_s64(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_u16(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_u32(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_u64(svbool_t_val, uint8_t_ptr_val); + svldnf1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + svldnf1uh_s32(svbool_t_val, uint16_t_ptr_val); + svldnf1uh_s64(svbool_t_val, uint16_t_ptr_val); + svldnf1uh_u32(svbool_t_val, uint16_t_ptr_val); + svldnf1uh_u64(svbool_t_val, uint16_t_ptr_val); + svldnf1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + svldnf1uw_s64(svbool_t_val, uint32_t_ptr_val); + svldnf1uw_u64(svbool_t_val, uint32_t_ptr_val); + svldnf1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svldnf1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svprfb_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfb_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfb_gather_s32offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfb_gather_s64offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfb_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfb_gather_u32base_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfb_gather_u32offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfb_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfb_gather_u64base_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfb_gather_u64offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfd_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfd_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfd_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfd_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfd_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfd_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfd_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfd_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfd_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfd_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfh_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfh_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfh_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfh_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfh_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfh_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfh_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfh_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfh_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfh_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfw_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfw_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svprfw_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + svprfw_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + svprfw_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + svprfw_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + svprfw_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + svprfw_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + svprfw_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + svprfw_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + svrdffr(); + svrdffr_z(svbool_t_val); + svsetffr(); + svst1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1_scatter_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + svst1_scatter_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + svst1_scatter_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1_scatter_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + svst1_scatter_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + svst1_scatter_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svst1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svst1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1_scatter_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1_scatter_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svst1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1b_scatter_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + svst1b_scatter_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + svst1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + svst1h_scatter_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1h_scatter_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + svst1h_scatter_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + svst1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svst1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svst1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svst1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svst1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svst1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1h_scatter_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svst1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svst1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svst1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svst1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svtmad(svfloat16_t_val, svfloat16_t_val, 2); + svtmad(svfloat32_t_val, svfloat32_t_val, 2); + svtmad(svfloat64_t_val, svfloat64_t_val, 2); + svtmad_f16(svfloat16_t_val, svfloat16_t_val, 2); + svtmad_f32(svfloat32_t_val, svfloat32_t_val, 2); + svtmad_f64(svfloat64_t_val, svfloat64_t_val, 2); + svtsmul(svfloat16_t_val, svuint16_t_val); + svtsmul(svfloat32_t_val, svuint32_t_val); + svtsmul(svfloat64_t_val, svuint64_t_val); + svtsmul_f16(svfloat16_t_val, svuint16_t_val); + svtsmul_f32(svfloat32_t_val, svuint32_t_val); + svtsmul_f64(svfloat64_t_val, svuint64_t_val); + svtssel(svfloat16_t_val, svuint16_t_val); + svtssel(svfloat32_t_val, svuint32_t_val); + svtssel(svfloat64_t_val, svuint64_t_val); + svtssel_f16(svfloat16_t_val, svuint16_t_val); + svtssel_f32(svfloat32_t_val, svuint32_t_val); + svtssel_f64(svfloat64_t_val, svuint64_t_val); + svwrffr(svbool_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + void * void_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u32base_s32offset(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u32base_u32offset(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u64base_s64offset(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u64base_u64offset(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_s32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_s64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_u32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_u64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_s64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_u64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_s32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_s64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_u32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_u64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_s64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_u64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_s32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_s64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_u32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_u64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_s64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_u64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_s32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_s64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_u32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_u64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_s64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_u64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_s32offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_s64offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32base_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64base_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrdffr(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrdffr_z(svbool_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsetffr(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat16_t_val, svfloat16_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat32_t_val, svfloat32_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat64_t_val, svfloat64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f16(svfloat16_t_val, svfloat16_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f32(svfloat32_t_val, svfloat32_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f64(svfloat64_t_val, svfloat64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f16(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f32(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f64(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f16(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f32(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f64(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwrffr(svbool_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float16_t float16_t_val; + float32_t * float32_t_ptr_val; + float32_t float32_t_val; + float64_t * float64_t_ptr_val; + float64_t float64_t_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + void * void_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda(svbool_t_val, float64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f16(svbool_t_val, float16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f32(svbool_t_val, float32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadda_f64(svbool_t_val, float64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_offset(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u32base_s32offset(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u32base_u32offset(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u64base_s64offset(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrb_u64base_u64offset(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrd_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrh_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u32base_s32index(svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u32base_u32index(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u64base_s64index(svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svadrw_u64base_u64index(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s32offset_u32(svbool_t_val, int8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_s64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_u64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32index_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s32offset_u32(svbool_t_val, int16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32index_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_s32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_s64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_u32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_u64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_s64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_u64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32offset_s32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_s64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_u64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32index_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32offset_s32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32index_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_s32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_s64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_u32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_u64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_s64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_u64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldff1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_bf16(svbool_t_val, bfloat16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f16(svbool_t_val, float16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_mf8(svbool_t_val, mfloat8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s8(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s16(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u8(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u16(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_s64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u16(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u32(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_u64(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_s64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u16(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u32(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sb_vnum_u64(svbool_t_val, int8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_s32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_s64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_u32(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_u64(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_s32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_s64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_u32(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sh_vnum_u64(svbool_t_val, int16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_s64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_u64(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_vnum_s64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1sw_vnum_u64(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_s64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u16(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u32(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_u64(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_s64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u16(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u32(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1ub_vnum_u64(svbool_t_val, uint8_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_s32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_s64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_u32(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_u64(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_s32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_s64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_u32(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uh_vnum_u64(svbool_t_val, uint16_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_s64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_u64(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_vnum_s64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnf1uw_vnum_u64(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_s32offset(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_s64offset(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32base_offset(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u32offset(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64base_offset(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfb_gather_u64offset(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfd_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfh_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_s32index(svbool_t_val, void_ptr_val, svint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_s64index(svbool_t_val, void_ptr_val, svint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32base(svbool_t_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32base_index(svbool_t_val, svuint32_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u32index(svbool_t_val, void_ptr_val, svuint32_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64base(svbool_t_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64base_index(svbool_t_val, svuint64_t_val, int64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svprfw_gather_u64index(svbool_t_val, void_ptr_val, svuint64_t_val, SV_PSTL1KEEP); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrdffr(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svrdffr_z(svbool_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsetffr(); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32index_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_f32(svbool_t_val, float32_t_ptr_val, svint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s32offset_u32(svbool_t_val, uint32_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32index_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s32offset_s32(svbool_t_val, int8_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s32offset_u32(svbool_t_val, uint8_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32index_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32index_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32offset_s32(svbool_t_val, int16_t_ptr_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s32offset_u32(svbool_t_val, uint16_t_ptr_val, svint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32index_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32index_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat16_t_val, svfloat16_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat32_t_val, svfloat32_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad(svfloat64_t_val, svfloat64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f16(svfloat16_t_val, svfloat16_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f32(svfloat32_t_val, svfloat32_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtmad_f64(svfloat64_t_val, svfloat64_t_val, 2); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f16(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f32(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtsmul_f64(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f16(svfloat16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f32(svfloat32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtssel_f64(svfloat64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svwrffr(svbool_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_bf16.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_bf16.c new file mode 100644 index 0000000..8e1d820 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_bf16.c @@ -0,0 +1,36 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +bf16 -target-feature +sme -target-feature +sve -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,bf16" streaming_guard="" flags="" + +void test(void) { + svbfloat16_t svbfloat16_t_val; + svfloat32_t svfloat32_t_val; + + svbfmmla(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + svbfmmla_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); +} + +void test_streaming(void) __arm_streaming{ + svbfloat16_t svbfloat16_t_val; + svfloat32_t svfloat32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbfmmla(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbfmmla_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbfloat16_t svbfloat16_t_val; + svfloat32_t svfloat32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbfmmla(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svbfmmla_f32(svfloat32_t_val, svbfloat16_t_val, svbfloat16_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f32mm.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f32mm.c new file mode 100644 index 0000000..6976505 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f32mm.c @@ -0,0 +1,33 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +f32mm -target-feature +sme -target-feature +sve -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,f32mm" streaming_guard="" flags="" + +void test(void) { + svfloat32_t svfloat32_t_val; + + svmmla(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + svmmla_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); +} + +void test_streaming(void) __arm_streaming{ + svfloat32_t svfloat32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svfloat32_t svfloat32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_f32(svfloat32_t_val, svfloat32_t_val, svfloat32_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f64mm.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f64mm.c new file mode 100644 index 0000000..b904dea --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_f64mm.c @@ -0,0 +1,958 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +f64mm -target-feature +sme -target-feature +sve -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,f64mm" streaming_guard="" flags="" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svld1ro(svbool_t_val, bfloat16_t_ptr_val); + svld1ro(svbool_t_val, float16_t_ptr_val); + svld1ro(svbool_t_val, float32_t_ptr_val); + svld1ro(svbool_t_val, float64_t_ptr_val); + svld1ro(svbool_t_val, int8_t_ptr_val); + svld1ro(svbool_t_val, int16_t_ptr_val); + svld1ro(svbool_t_val, int32_t_ptr_val); + svld1ro(svbool_t_val, int64_t_ptr_val); + svld1ro(svbool_t_val, mfloat8_t_ptr_val); + svld1ro(svbool_t_val, uint8_t_ptr_val); + svld1ro(svbool_t_val, uint16_t_ptr_val); + svld1ro(svbool_t_val, uint32_t_ptr_val); + svld1ro(svbool_t_val, uint64_t_ptr_val); + svld1ro_bf16(svbool_t_val, bfloat16_t_ptr_val); + svld1ro_f16(svbool_t_val, float16_t_ptr_val); + svld1ro_f32(svbool_t_val, float32_t_ptr_val); + svld1ro_f64(svbool_t_val, float64_t_ptr_val); + svld1ro_mf8(svbool_t_val, mfloat8_t_ptr_val); + svld1ro_s8(svbool_t_val, int8_t_ptr_val); + svld1ro_s16(svbool_t_val, int16_t_ptr_val); + svld1ro_s32(svbool_t_val, int32_t_ptr_val); + svld1ro_s64(svbool_t_val, int64_t_ptr_val); + svld1ro_u8(svbool_t_val, uint8_t_ptr_val); + svld1ro_u16(svbool_t_val, uint16_t_ptr_val); + svld1ro_u32(svbool_t_val, uint32_t_ptr_val); + svld1ro_u64(svbool_t_val, uint64_t_ptr_val); + svmmla(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svmmla_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + svtrn1q(svbfloat16_t_val, svbfloat16_t_val); + svtrn1q(svfloat16_t_val, svfloat16_t_val); + svtrn1q(svfloat32_t_val, svfloat32_t_val); + svtrn1q(svfloat64_t_val, svfloat64_t_val); + svtrn1q(svint8_t_val, svint8_t_val); + svtrn1q(svint16_t_val, svint16_t_val); + svtrn1q(svint32_t_val, svint32_t_val); + svtrn1q(svint64_t_val, svint64_t_val); + svtrn1q(svuint8_t_val, svuint8_t_val); + svtrn1q(svuint16_t_val, svuint16_t_val); + svtrn1q(svuint32_t_val, svuint32_t_val); + svtrn1q(svuint64_t_val, svuint64_t_val); + svtrn1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn1q_f16(svfloat16_t_val, svfloat16_t_val); + svtrn1q_f32(svfloat32_t_val, svfloat32_t_val); + svtrn1q_f64(svfloat64_t_val, svfloat64_t_val); + svtrn1q_s8(svint8_t_val, svint8_t_val); + svtrn1q_s16(svint16_t_val, svint16_t_val); + svtrn1q_s32(svint32_t_val, svint32_t_val); + svtrn1q_s64(svint64_t_val, svint64_t_val); + svtrn1q_u8(svuint8_t_val, svuint8_t_val); + svtrn1q_u16(svuint16_t_val, svuint16_t_val); + svtrn1q_u32(svuint32_t_val, svuint32_t_val); + svtrn1q_u64(svuint64_t_val, svuint64_t_val); + svtrn2q(svbfloat16_t_val, svbfloat16_t_val); + svtrn2q(svfloat16_t_val, svfloat16_t_val); + svtrn2q(svfloat32_t_val, svfloat32_t_val); + svtrn2q(svfloat64_t_val, svfloat64_t_val); + svtrn2q(svint8_t_val, svint8_t_val); + svtrn2q(svint16_t_val, svint16_t_val); + svtrn2q(svint32_t_val, svint32_t_val); + svtrn2q(svint64_t_val, svint64_t_val); + svtrn2q(svuint8_t_val, svuint8_t_val); + svtrn2q(svuint16_t_val, svuint16_t_val); + svtrn2q(svuint32_t_val, svuint32_t_val); + svtrn2q(svuint64_t_val, svuint64_t_val); + svtrn2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svtrn2q_f16(svfloat16_t_val, svfloat16_t_val); + svtrn2q_f32(svfloat32_t_val, svfloat32_t_val); + svtrn2q_f64(svfloat64_t_val, svfloat64_t_val); + svtrn2q_s8(svint8_t_val, svint8_t_val); + svtrn2q_s16(svint16_t_val, svint16_t_val); + svtrn2q_s32(svint32_t_val, svint32_t_val); + svtrn2q_s64(svint64_t_val, svint64_t_val); + svtrn2q_u8(svuint8_t_val, svuint8_t_val); + svtrn2q_u16(svuint16_t_val, svuint16_t_val); + svtrn2q_u32(svuint32_t_val, svuint32_t_val); + svtrn2q_u64(svuint64_t_val, svuint64_t_val); + svuzp1q(svbfloat16_t_val, svbfloat16_t_val); + svuzp1q(svfloat16_t_val, svfloat16_t_val); + svuzp1q(svfloat32_t_val, svfloat32_t_val); + svuzp1q(svfloat64_t_val, svfloat64_t_val); + svuzp1q(svint8_t_val, svint8_t_val); + svuzp1q(svint16_t_val, svint16_t_val); + svuzp1q(svint32_t_val, svint32_t_val); + svuzp1q(svint64_t_val, svint64_t_val); + svuzp1q(svuint8_t_val, svuint8_t_val); + svuzp1q(svuint16_t_val, svuint16_t_val); + svuzp1q(svuint32_t_val, svuint32_t_val); + svuzp1q(svuint64_t_val, svuint64_t_val); + svuzp1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp1q_f16(svfloat16_t_val, svfloat16_t_val); + svuzp1q_f32(svfloat32_t_val, svfloat32_t_val); + svuzp1q_f64(svfloat64_t_val, svfloat64_t_val); + svuzp1q_s8(svint8_t_val, svint8_t_val); + svuzp1q_s16(svint16_t_val, svint16_t_val); + svuzp1q_s32(svint32_t_val, svint32_t_val); + svuzp1q_s64(svint64_t_val, svint64_t_val); + svuzp1q_u8(svuint8_t_val, svuint8_t_val); + svuzp1q_u16(svuint16_t_val, svuint16_t_val); + svuzp1q_u32(svuint32_t_val, svuint32_t_val); + svuzp1q_u64(svuint64_t_val, svuint64_t_val); + svuzp2q(svbfloat16_t_val, svbfloat16_t_val); + svuzp2q(svfloat16_t_val, svfloat16_t_val); + svuzp2q(svfloat32_t_val, svfloat32_t_val); + svuzp2q(svfloat64_t_val, svfloat64_t_val); + svuzp2q(svint8_t_val, svint8_t_val); + svuzp2q(svint16_t_val, svint16_t_val); + svuzp2q(svint32_t_val, svint32_t_val); + svuzp2q(svint64_t_val, svint64_t_val); + svuzp2q(svuint8_t_val, svuint8_t_val); + svuzp2q(svuint16_t_val, svuint16_t_val); + svuzp2q(svuint32_t_val, svuint32_t_val); + svuzp2q(svuint64_t_val, svuint64_t_val); + svuzp2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svuzp2q_f16(svfloat16_t_val, svfloat16_t_val); + svuzp2q_f32(svfloat32_t_val, svfloat32_t_val); + svuzp2q_f64(svfloat64_t_val, svfloat64_t_val); + svuzp2q_s8(svint8_t_val, svint8_t_val); + svuzp2q_s16(svint16_t_val, svint16_t_val); + svuzp2q_s32(svint32_t_val, svint32_t_val); + svuzp2q_s64(svint64_t_val, svint64_t_val); + svuzp2q_u8(svuint8_t_val, svuint8_t_val); + svuzp2q_u16(svuint16_t_val, svuint16_t_val); + svuzp2q_u32(svuint32_t_val, svuint32_t_val); + svuzp2q_u64(svuint64_t_val, svuint64_t_val); + svzip1q(svbfloat16_t_val, svbfloat16_t_val); + svzip1q(svfloat16_t_val, svfloat16_t_val); + svzip1q(svfloat32_t_val, svfloat32_t_val); + svzip1q(svfloat64_t_val, svfloat64_t_val); + svzip1q(svint8_t_val, svint8_t_val); + svzip1q(svint16_t_val, svint16_t_val); + svzip1q(svint32_t_val, svint32_t_val); + svzip1q(svint64_t_val, svint64_t_val); + svzip1q(svuint8_t_val, svuint8_t_val); + svzip1q(svuint16_t_val, svuint16_t_val); + svzip1q(svuint32_t_val, svuint32_t_val); + svzip1q(svuint64_t_val, svuint64_t_val); + svzip1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip1q_f16(svfloat16_t_val, svfloat16_t_val); + svzip1q_f32(svfloat32_t_val, svfloat32_t_val); + svzip1q_f64(svfloat64_t_val, svfloat64_t_val); + svzip1q_s8(svint8_t_val, svint8_t_val); + svzip1q_s16(svint16_t_val, svint16_t_val); + svzip1q_s32(svint32_t_val, svint32_t_val); + svzip1q_s64(svint64_t_val, svint64_t_val); + svzip1q_u8(svuint8_t_val, svuint8_t_val); + svzip1q_u16(svuint16_t_val, svuint16_t_val); + svzip1q_u32(svuint32_t_val, svuint32_t_val); + svzip1q_u64(svuint64_t_val, svuint64_t_val); + svzip2q(svbfloat16_t_val, svbfloat16_t_val); + svzip2q(svfloat16_t_val, svfloat16_t_val); + svzip2q(svfloat32_t_val, svfloat32_t_val); + svzip2q(svfloat64_t_val, svfloat64_t_val); + svzip2q(svint8_t_val, svint8_t_val); + svzip2q(svint16_t_val, svint16_t_val); + svzip2q(svint32_t_val, svint32_t_val); + svzip2q(svint64_t_val, svint64_t_val); + svzip2q(svuint8_t_val, svuint8_t_val); + svzip2q(svuint16_t_val, svuint16_t_val); + svzip2q(svuint32_t_val, svuint32_t_val); + svzip2q(svuint64_t_val, svuint64_t_val); + svzip2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + svzip2q_f16(svfloat16_t_val, svfloat16_t_val); + svzip2q_f32(svfloat32_t_val, svfloat32_t_val); + svzip2q_f64(svfloat64_t_val, svfloat64_t_val); + svzip2q_s8(svint8_t_val, svint8_t_val); + svzip2q_s16(svint16_t_val, svint16_t_val); + svzip2q_s32(svint32_t_val, svint32_t_val); + svzip2q_s64(svint64_t_val, svint64_t_val); + svzip2q_u8(svuint8_t_val, svuint8_t_val); + svzip2q_u16(svuint16_t_val, svuint16_t_val); + svzip2q_u32(svuint32_t_val, svuint32_t_val); + svzip2q_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u64(svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_bf16(svbool_t_val, bfloat16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f16(svbool_t_val, float16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_mf8(svbool_t_val, mfloat8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s8(svbool_t_val, int8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s16(svbool_t_val, int16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u8(svbool_t_val, uint8_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u16(svbool_t_val, uint16_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1ro_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_f64(svfloat64_t_val, svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svtrn2q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svuzp2q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip1q_u64(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q(svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_bf16(svbfloat16_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f16(svfloat16_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f32(svfloat32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_f64(svfloat64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s16(svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s32(svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_s64(svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u16(svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svzip2q_u64(svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_i8mm.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_i8mm.c new file mode 100644 index 0000000..815a80f --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_i8mm.c @@ -0,0 +1,62 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +i8mm -target-feature +sme -target-feature +sve -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,i8mm" streaming_guard="" flags="" + +void test(void) { + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + svuint32_t svuint32_t_val; + + svmmla(svint32_t_val, svint8_t_val, svint8_t_val); + svmmla(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svmmla_s32(svint32_t_val, svint8_t_val, svint8_t_val); + svmmla_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + svusmmla(svint32_t_val, svuint8_t_val, svint8_t_val); + svusmmla_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} + +void test_streaming(void) __arm_streaming{ + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + svuint32_t svuint32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svint32_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svuint32_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_s32(svint32_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svusmmla(svint32_t_val, svuint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svusmmla_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svint8_t svint8_t_val; + svint32_t svint32_t_val; + svuint8_t svuint8_t_val; + svuint32_t svuint32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svint32_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla(svuint32_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_s32(svint32_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmmla_u32(svuint32_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svusmmla(svint32_t_val, svuint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svusmmla_s32(svint32_t_val, svuint8_t_val, svint8_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve-sm4.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve-sm4.c new file mode 100644 index 0000000..0cc3b78 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve-sm4.c @@ -0,0 +1,43 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve-sm4 -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve-sm4" streaming_guard="" flags="" + +void test(void) { + svuint32_t svuint32_t_val; + + svsm4e(svuint32_t_val, svuint32_t_val); + svsm4e_u32(svuint32_t_val, svuint32_t_val); + svsm4ekey(svuint32_t_val, svuint32_t_val); + svsm4ekey_u32(svuint32_t_val, svuint32_t_val); +} + +void test_streaming(void) __arm_streaming{ + svuint32_t svuint32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4e(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4e_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4ekey(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4ekey_u32(svuint32_t_val, svuint32_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svuint32_t svuint32_t_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4e(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4e_u32(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4ekey(svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svsm4ekey_u32(svuint32_t_val, svuint32_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2.c new file mode 100644 index 0000000..b80ebb6 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2.c @@ -0,0 +1,2386 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2 -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2" streaming_guard="" flags="" + +void test(void) { + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svhistcnt_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhistcnt_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhistcnt_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhistcnt_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhistcnt_z(svbool_t_val, svint32_t_val, svint32_t_val); + svhistcnt_z(svbool_t_val, svint64_t_val, svint64_t_val); + svhistcnt_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + svhistcnt_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + svhistseg(svint8_t_val, svint8_t_val); + svhistseg(svuint8_t_val, svuint8_t_val); + svhistseg_s8(svint8_t_val, svint8_t_val); + svhistseg_u8(svuint8_t_val, svuint8_t_val); + svldnt1_gather_f32(svbool_t_val, svuint32_t_val); + svldnt1_gather_f64(svbool_t_val, svuint64_t_val); + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldnt1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldnt1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldnt1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldnt1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_s32(svbool_t_val, svuint32_t_val); + svldnt1_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldnt1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldnt1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldnt1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + svldnt1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svldnt1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + svldnt1_gather_u32(svbool_t_val, svuint32_t_val); + svldnt1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + svldnt1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldnt1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldnt1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + svldnt1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + svldnt1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svldnt1_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + svldnt1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldnt1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldnt1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldnt1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svldnt1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svldnt1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svldnt1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldnt1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldnt1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldnt1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldnt1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sb_gather_s32(svbool_t_val, svuint32_t_val); + svldnt1sb_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldnt1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + svldnt1sb_gather_u32(svbool_t_val, svuint32_t_val); + svldnt1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldnt1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldnt1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldnt1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + svldnt1sb_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldnt1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldnt1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldnt1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_s32(svbool_t_val, svuint32_t_val); + svldnt1sh_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + svldnt1sh_gather_u32(svbool_t_val, svuint32_t_val); + svldnt1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldnt1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldnt1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldnt1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + svldnt1sh_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + svldnt1sw_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svldnt1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldnt1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldnt1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldnt1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldnt1ub_gather_s32(svbool_t_val, svuint32_t_val); + svldnt1ub_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldnt1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + svldnt1ub_gather_u32(svbool_t_val, svuint32_t_val); + svldnt1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldnt1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldnt1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldnt1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + svldnt1ub_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldnt1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldnt1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldnt1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_s32(svbool_t_val, svuint32_t_val); + svldnt1uh_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + svldnt1uh_gather_u32(svbool_t_val, svuint32_t_val); + svldnt1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + svldnt1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + svldnt1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + svldnt1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldnt1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + svldnt1uh_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_s64(svbool_t_val, svuint64_t_val); + svldnt1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + svldnt1uw_gather_u64(svbool_t_val, svuint64_t_val); + svldnt1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svldnt1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svldnt1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svldnt1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svldnt1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svmatch(svbool_t_val, svint8_t_val, svint8_t_val); + svmatch(svbool_t_val, svint16_t_val, svint16_t_val); + svmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + svmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svnmatch(svbool_t_val, svint8_t_val, svint8_t_val); + svnmatch(svbool_t_val, svint16_t_val, svint16_t_val); + svnmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + svnmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + svnmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + svnmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + svnmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + svnmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + svstnt1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + svstnt1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svstnt1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svstnt1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + svstnt1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svstnt1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + svstnt1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + svstnt1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svstnt1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svstnt1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svstnt1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + svstnt1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + svstnt1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + svstnt1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + svstnt1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + svstnt1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + svstnt1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + svstnt1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + svstnt1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svstnt1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svstnt1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + svstnt1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + svstnt1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + svbool_t svbool_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_s32_z(svbool_t_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_s64_z(svbool_t_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_u32_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_u64_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistcnt_z(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg_s8(svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svhistseg_u8(svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_f32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_s64offset_u64(svbool_t_val, int8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u32offset_u32(svbool_t_val, int8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sb_gather_u64offset_u64(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64index_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_s64offset_u64(svbool_t_val, int16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u32offset_u32(svbool_t_val, int16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64index_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sh_gather_u64offset_u64(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64index_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_s64offset_u64(svbool_t_val, int32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64index_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1sw_gather_u64offset_u64(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64offset_s64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32offset_s32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64offset_s64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1ub_gather_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64index_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64offset_s64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_s32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32base_u32(svbool_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32offset_s32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64index_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64offset_s64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uh_gather_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64index_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64offset_s64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64index_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64offset_s64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svldnt1uw_gather_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_s8(svbool_t_val, svint8_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_s16(svbool_t_val, svint16_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_u8(svbool_t_val, svuint8_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svnmatch_u16(svbool_t_val, svuint16_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_f32(svbool_t_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_f32(svbool_t_val, svuint32_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_f32(svbool_t_val, float32_t_ptr_val, svuint32_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_s32(svbool_t_val, int32_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u32offset_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_s64offset_s64(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_s64offset_u64(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32offset_s32(svbool_t_val, int8_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u32offset_u32(svbool_t_val, uint8_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64offset_s64(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1b_scatter_u64offset_u64(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64index_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64index_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64offset_s64(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_s64offset_u64(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_index_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_index_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_offset_s32(svbool_t_val, svuint32_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_offset_u32(svbool_t_val, svuint32_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_s32(svbool_t_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32base_u32(svbool_t_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32offset_s32(svbool_t_val, int16_t_ptr_val, svuint32_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u32offset_u32(svbool_t_val, uint16_t_ptr_val, svuint32_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64index_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64index_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64offset_s64(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1h_scatter_u64offset_u64(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64index_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64index_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64offset_s64(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_s64offset_u64(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64index_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64index_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64offset_s64(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svstnt1w_scatter_u64offset_u64(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2p1.c b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2p1.c new file mode 100644 index 0000000..d5bdad9 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_non_streaming_only_sve_AND_sve2p1.c @@ -0,0 +1,1754 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sve -target-feature +sve2p1 -verify=guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="sve,sve2p1" streaming_guard="" flags="" + +void test(void) { + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + svld1q_gather_bf16(svbool_t_val, svuint64_t_val); + svld1q_gather_f16(svbool_t_val, svuint64_t_val); + svld1q_gather_f32(svbool_t_val, svuint64_t_val); + svld1q_gather_f64(svbool_t_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1q_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1q_gather_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_mf8(svbool_t_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1q_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1q_gather_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_s8(svbool_t_val, svuint64_t_val); + svld1q_gather_s16(svbool_t_val, svuint64_t_val); + svld1q_gather_s32(svbool_t_val, svuint64_t_val); + svld1q_gather_s64(svbool_t_val, svuint64_t_val); + svld1q_gather_u8(svbool_t_val, svuint64_t_val); + svld1q_gather_u16(svbool_t_val, svuint64_t_val); + svld1q_gather_u32(svbool_t_val, svuint64_t_val); + svld1q_gather_u64(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_bf16(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_f16(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_f32(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_f64(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_mf8(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + svld1q_gather_u64base_s8(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_s16(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_s32(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_s64(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_u8(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_u16(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_u32(svbool_t_val, svuint64_t_val); + svld1q_gather_u64base_u64(svbool_t_val, svuint64_t_val); + svld1q_gather_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + svld1q_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svld1udq(svbool_t_val, float64_t_ptr_val); + svld1udq(svbool_t_val, int64_t_ptr_val); + svld1udq(svbool_t_val, uint64_t_ptr_val); + svld1udq_f64(svbool_t_val, float64_t_ptr_val); + svld1udq_s64(svbool_t_val, int64_t_ptr_val); + svld1udq_u64(svbool_t_val, uint64_t_ptr_val); + svld1udq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1udq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1udq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1udq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + svld1udq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + svld1udq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + svld1uwq(svbool_t_val, float32_t_ptr_val); + svld1uwq(svbool_t_val, int32_t_ptr_val); + svld1uwq(svbool_t_val, uint32_t_ptr_val); + svld1uwq_f32(svbool_t_val, float32_t_ptr_val); + svld1uwq_s32(svbool_t_val, int32_t_ptr_val); + svld1uwq_u32(svbool_t_val, uint32_t_ptr_val); + svld1uwq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1uwq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1uwq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svld1uwq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + svld1uwq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + svld1uwq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + svst1dq(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1dq(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1dq(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1dq_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + svst1dq_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + svst1dq_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + svst1dq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1dq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1dq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1dq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + svst1dq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + svst1dq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svint8_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svint16_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svint32_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint8_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1q_scatter_s64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + svst1q_scatter_s64index_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + svst1q_scatter_s64index_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + svst1q_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1q_scatter_s64index_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + svst1q_scatter_s64index_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + svst1q_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1q_scatter_s64index_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + svst1q_scatter_s64index_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + svst1q_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1q_scatter_s64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + svst1q_scatter_s64offset_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + svst1q_scatter_s64offset_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + svst1q_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + svst1q_scatter_s64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + svst1q_scatter_s64offset_s8(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + svst1q_scatter_s64offset_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + svst1q_scatter_s64offset_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + svst1q_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + svst1q_scatter_s64offset_u8(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + svst1q_scatter_s64offset_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + svst1q_scatter_s64offset_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + svst1q_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + svst1q_scatter_u64base_bf16(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter_u64base_f16(svbool_t_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter_u64base_f32(svbool_t_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + svst1q_scatter_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + svst1q_scatter_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + svst1q_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1q_scatter_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + svst1q_scatter_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + svst1q_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1q_scatter_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + svst1q_scatter_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + svst1q_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1q_scatter_u64base_mf8(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + svst1q_scatter_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + svst1q_scatter_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + svst1q_scatter_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + svst1q_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + svst1q_scatter_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + svst1q_scatter_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + svst1q_scatter_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + svst1q_scatter_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + svst1q_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + svst1q_scatter_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + svst1q_scatter_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + svst1q_scatter_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + svst1q_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + svst1q_scatter_u64base_s8(svbool_t_val, svuint64_t_val, svint8_t_val); + svst1q_scatter_u64base_s16(svbool_t_val, svuint64_t_val, svint16_t_val); + svst1q_scatter_u64base_s32(svbool_t_val, svuint64_t_val, svint32_t_val); + svst1q_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + svst1q_scatter_u64base_u8(svbool_t_val, svuint64_t_val, svuint8_t_val); + svst1q_scatter_u64base_u16(svbool_t_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter_u64base_u32(svbool_t_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + svst1q_scatter_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + svst1q_scatter_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + svst1q_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1q_scatter_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1q_scatter_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + svst1q_scatter_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + svst1q_scatter_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + svst1q_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + svst1q_scatter_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + svst1q_scatter_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + svst1q_scatter_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + svst1q_scatter_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + svst1q_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + svst1q_scatter_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + svst1q_scatter_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + svst1q_scatter_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + svst1q_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + svst1wq(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1wq(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1wq(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1wq_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + svst1wq_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + svst1wq_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + svst1wq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1wq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1wq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + svst1wq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + svst1wq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + svst1wq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); +} + +void test_streaming(void) __arm_streaming{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_bf16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_mf8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_bf16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_mf8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s8(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u8(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_bf16(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f16(svbool_t_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f32(svbool_t_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_mf8(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s8(svbool_t_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s16(svbool_t_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s32(svbool_t_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u8(svbool_t_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u16(svbool_t_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u32(svbool_t_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + bfloat16_t * bfloat16_t_ptr_val; + float16_t * float16_t_ptr_val; + float32_t * float32_t_ptr_val; + float64_t * float64_t_ptr_val; + int8_t * int8_t_ptr_val; + int16_t * int16_t_ptr_val; + int32_t * int32_t_ptr_val; + int64_t * int64_t_ptr_val; + int64_t int64_t_val; + mfloat8_t * mfloat8_t_ptr_val; + svbfloat16_t svbfloat16_t_val; + svbool_t svbool_t_val; + svfloat16_t svfloat16_t_val; + svfloat32_t svfloat32_t_val; + svfloat64_t svfloat64_t_val; + svint8_t svint8_t_val; + svint16_t svint16_t_val; + svint32_t svint32_t_val; + svint64_t svint64_t_val; + svmfloat8_t svmfloat8_t_val; + svuint8_t svuint8_t_val; + svuint16_t svuint16_t_val; + svuint32_t svuint32_t_val; + svuint64_t svuint64_t_val; + uint8_t * uint8_t_ptr_val; + uint16_t * uint16_t_ptr_val; + uint32_t * uint32_t_ptr_val; + uint64_t * uint64_t_ptr_val; + + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_bf16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_mf8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_bf16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_f64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_mf8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_s64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u8(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u16(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u32(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64base_u64(svbool_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1q_gather_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_f64(svbool_t_val, float64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_s64(svbool_t_val, int64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_u64(svbool_t_val, uint64_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1udq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_f32(svbool_t_val, float32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_s32(svbool_t_val, int32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_u32(svbool_t_val, uint32_t_ptr_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svld1uwq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_f64(svbool_t_val, float64_t_ptr_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_f64(svbool_t_val, float64_t_ptr_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_s64(svbool_t_val, int64_t_ptr_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1dq_vnum_u64(svbool_t_val, uint64_t_ptr_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_index(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_offset(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64index_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f16(svbool_t_val, float16_t_ptr_val, svint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f32(svbool_t_val, float32_t_ptr_val, svint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_f64(svbool_t_val, float64_t_ptr_val, svint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s8(svbool_t_val, int8_t_ptr_val, svint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s16(svbool_t_val, int16_t_ptr_val, svint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s32(svbool_t_val, int32_t_ptr_val, svint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_s64(svbool_t_val, int64_t_ptr_val, svint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u8(svbool_t_val, uint8_t_ptr_val, svint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u16(svbool_t_val, uint16_t_ptr_val, svint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u32(svbool_t_val, uint32_t_ptr_val, svint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_s64offset_u64(svbool_t_val, uint64_t_ptr_val, svint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_bf16(svbool_t_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f16(svbool_t_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f32(svbool_t_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_f64(svbool_t_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_index_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_mf8(svbool_t_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_bf16(svbool_t_val, svuint64_t_val, int64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f16(svbool_t_val, svuint64_t_val, int64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f32(svbool_t_val, svuint64_t_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_f64(svbool_t_val, svuint64_t_val, int64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_mf8(svbool_t_val, svuint64_t_val, int64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s8(svbool_t_val, svuint64_t_val, int64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s16(svbool_t_val, svuint64_t_val, int64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s32(svbool_t_val, svuint64_t_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_s64(svbool_t_val, svuint64_t_val, int64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u8(svbool_t_val, svuint64_t_val, int64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u16(svbool_t_val, svuint64_t_val, int64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u32(svbool_t_val, svuint64_t_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_offset_u64(svbool_t_val, svuint64_t_val, int64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s8(svbool_t_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s16(svbool_t_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s32(svbool_t_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_s64(svbool_t_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u8(svbool_t_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u16(svbool_t_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u32(svbool_t_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64base_u64(svbool_t_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64index_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_bf16(svbool_t_val, bfloat16_t_ptr_val, svuint64_t_val, svbfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f16(svbool_t_val, float16_t_ptr_val, svuint64_t_val, svfloat16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f32(svbool_t_val, float32_t_ptr_val, svuint64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_f64(svbool_t_val, float64_t_ptr_val, svuint64_t_val, svfloat64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_mf8(svbool_t_val, mfloat8_t_ptr_val, svuint64_t_val, svmfloat8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s8(svbool_t_val, int8_t_ptr_val, svuint64_t_val, svint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s16(svbool_t_val, int16_t_ptr_val, svuint64_t_val, svint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s32(svbool_t_val, int32_t_ptr_val, svuint64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_s64(svbool_t_val, int64_t_ptr_val, svuint64_t_val, svint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u8(svbool_t_val, uint8_t_ptr_val, svuint64_t_val, svuint8_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u16(svbool_t_val, uint16_t_ptr_val, svuint64_t_val, svuint16_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u32(svbool_t_val, uint32_t_ptr_val, svuint64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1q_scatter_u64offset_u64(svbool_t_val, uint64_t_ptr_val, svuint64_t_val, svuint64_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_f32(svbool_t_val, float32_t_ptr_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_s32(svbool_t_val, int32_t_ptr_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_u32(svbool_t_val, uint32_t_ptr_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_f32(svbool_t_val, float32_t_ptr_val, int64_t_val, svfloat32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_s32(svbool_t_val, int32_t_ptr_val, int64_t_val, svint32_t_val); + // guard-error@+1 {{builtin can only be called from a non-streaming function}} + svst1wq_vnum_u32(svbool_t_val, uint32_t_ptr_val, int64_t_val, svuint32_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme-f16f16.c b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme-f16f16.c new file mode 100644 index 0000000..eabd68c --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme-f16f16.c @@ -0,0 +1,43 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme-f16f16 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="" streaming_guard="sme,sme-f16f16" flags="streaming-only" + +void test(void) { + svfloat16_t svfloat16_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_f16_x2(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl_f32(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl_f32_f16_x2(svfloat16_t_val); +} + +void test_streaming(void) __arm_streaming{ + svfloat16_t svfloat16_t_val; + + svcvt_f32(svfloat16_t_val); + svcvt_f32_f16_x2(svfloat16_t_val); + svcvtl_f32(svfloat16_t_val); + svcvtl_f32_f16_x2(svfloat16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svfloat16_t svfloat16_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_f16_x2(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl_f32(svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl_f32_f16_x2(svfloat16_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2.c b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2.c new file mode 100644 index 0000000..9fb12be --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2.c @@ -0,0 +1,4034 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="" streaming_guard="sme,sme2" flags="streaming-only" + +void test(void) { + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svcount_t svcount_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint8x2_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint8x4_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint16x2_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint16x4_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint32x2_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint32x4_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint64x2_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint64x4_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s8_x2(svint8x2_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s8_x4(svint8x4_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s16_x2(svint16x2_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s16_x4(svint16x4_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s32_x2(svint32x2_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s32_x4(svint32x4_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s64_x2(svint64x2_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s64_x4(svint64x4_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u8_x2(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u8_x4(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u16_x2(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u16_x4(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u32_x2(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u32_x4(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u64_x2(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u64_x4(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_bf16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_bf16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_bf16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_bf16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_f16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_f16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s16_s32_x2(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u8_u32_x4(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u16_u32_x2(svuint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u16_u64_x4(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s16(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u8(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u16(svuint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u16(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_s8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_s16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_u8_u32_x4(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_u16_u64_x4(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_s8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_s16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_u8(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_u16(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u16_s32_x2(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u16(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_n_u8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_n_u16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_u8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_u16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_bf16_x2(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_bf16_x4(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f16_x2(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f16_x4(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f32_x2(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f32_x4(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f64_x2(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f64_x4(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_mf8_x2(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_mf8_x4(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s8_x2(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s8_x4(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s16_x2(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s16_x4(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s32_x2(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s32_x4(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s64_x2(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s64_x4(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u8_x2(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u8_x4(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u16_x2(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u16_x4(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u32_x2(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u32_x4(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u64_x2(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u64_x4(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16_s8_x2(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16_s8_x4(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32_s16_x2(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32_s16_x4(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64_s32_x2(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64_s32_x4(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16_u8_x2(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16_u8_x4(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32_u16_x2(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32_u16_x4(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64_u32_x2(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64_u32_x4(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u64_x4(svuint64x4_t_val); +} + +void test_streaming(void) __arm_streaming{ + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svcount_t svcount_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + + svadd(svint8x2_t_val, svint8_t_val); + svadd(svint8x4_t_val, svint8_t_val); + svadd(svint16x2_t_val, svint16_t_val); + svadd(svint16x4_t_val, svint16_t_val); + svadd(svint32x2_t_val, svint32_t_val); + svadd(svint32x4_t_val, svint32_t_val); + svadd(svint64x2_t_val, svint64_t_val); + svadd(svint64x4_t_val, svint64_t_val); + svadd(svuint8x2_t_val, svuint8_t_val); + svadd(svuint8x4_t_val, svuint8_t_val); + svadd(svuint16x2_t_val, svuint16_t_val); + svadd(svuint16x4_t_val, svuint16_t_val); + svadd(svuint32x2_t_val, svuint32_t_val); + svadd(svuint32x4_t_val, svuint32_t_val); + svadd(svuint64x2_t_val, svuint64_t_val); + svadd(svuint64x4_t_val, svuint64_t_val); + svadd_single_s8_x2(svint8x2_t_val, svint8_t_val); + svadd_single_s8_x4(svint8x4_t_val, svint8_t_val); + svadd_single_s16_x2(svint16x2_t_val, svint16_t_val); + svadd_single_s16_x4(svint16x4_t_val, svint16_t_val); + svadd_single_s32_x2(svint32x2_t_val, svint32_t_val); + svadd_single_s32_x4(svint32x4_t_val, svint32_t_val); + svadd_single_s64_x2(svint64x2_t_val, svint64_t_val); + svadd_single_s64_x4(svint64x4_t_val, svint64_t_val); + svadd_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + svadd_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + svadd_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + svadd_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + svadd_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + svadd_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + svadd_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + svadd_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + svclamp(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp(svint8x2_t_val, svint8_t_val, svint8_t_val); + svclamp(svint8x4_t_val, svint8_t_val, svint8_t_val); + svclamp(svint16x2_t_val, svint16_t_val, svint16_t_val); + svclamp(svint16x4_t_val, svint16_t_val, svint16_t_val); + svclamp(svint32x2_t_val, svint32_t_val, svint32_t_val); + svclamp(svint32x4_t_val, svint32_t_val, svint32_t_val); + svclamp(svint64x2_t_val, svint64_t_val, svint64_t_val); + svclamp(svint64x4_t_val, svint64_t_val, svint64_t_val); + svclamp(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + svclamp(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + svclamp(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + svclamp(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + svclamp(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + svclamp(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + svclamp(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + svclamp(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + svclamp_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + svclamp_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + svclamp_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + svclamp_single_s8_x2(svint8x2_t_val, svint8_t_val, svint8_t_val); + svclamp_single_s8_x4(svint8x4_t_val, svint8_t_val, svint8_t_val); + svclamp_single_s16_x2(svint16x2_t_val, svint16_t_val, svint16_t_val); + svclamp_single_s16_x4(svint16x4_t_val, svint16_t_val, svint16_t_val); + svclamp_single_s32_x2(svint32x2_t_val, svint32_t_val, svint32_t_val); + svclamp_single_s32_x4(svint32x4_t_val, svint32_t_val, svint32_t_val); + svclamp_single_s64_x2(svint64x2_t_val, svint64_t_val, svint64_t_val); + svclamp_single_s64_x4(svint64x4_t_val, svint64_t_val, svint64_t_val); + svclamp_single_u8_x2(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + svclamp_single_u8_x4(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + svclamp_single_u16_x2(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + svclamp_single_u16_x4(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + svclamp_single_u32_x2(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + svclamp_single_u32_x4(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + svclamp_single_u64_x2(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + svclamp_single_u64_x4(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + svcvt_bf16(svfloat32x2_t_val); + svcvt_bf16_f32_x2(svfloat32x2_t_val); + svcvt_f16(svfloat32x2_t_val); + svcvt_f16_f32_x2(svfloat32x2_t_val); + svcvt_f32(svint32x2_t_val); + svcvt_f32(svint32x4_t_val); + svcvt_f32(svuint32x2_t_val); + svcvt_f32(svuint32x4_t_val); + svcvt_f32_s32_x2(svint32x2_t_val); + svcvt_f32_s32_x4(svint32x4_t_val); + svcvt_f32_u32_x2(svuint32x2_t_val); + svcvt_f32_u32_x4(svuint32x4_t_val); + svcvt_s32(svfloat32x2_t_val); + svcvt_s32(svfloat32x4_t_val); + svcvt_s32_f32_x2(svfloat32x2_t_val); + svcvt_s32_f32_x4(svfloat32x4_t_val); + svcvt_u32(svfloat32x2_t_val); + svcvt_u32(svfloat32x4_t_val); + svcvt_u32_f32_x2(svfloat32x2_t_val); + svcvt_u32_f32_x4(svfloat32x4_t_val); + svcvtn_bf16(svfloat32x2_t_val); + svcvtn_bf16_f32_x2(svfloat32x2_t_val); + svcvtn_f16(svfloat32x2_t_val); + svcvtn_f16_f32_x2(svfloat32x2_t_val); + svmax(svfloat16x2_t_val, svfloat16_t_val); + svmax(svfloat16x2_t_val, svfloat16x2_t_val); + svmax(svfloat16x4_t_val, svfloat16_t_val); + svmax(svfloat16x4_t_val, svfloat16x4_t_val); + svmax(svfloat32x2_t_val, svfloat32_t_val); + svmax(svfloat32x2_t_val, svfloat32x2_t_val); + svmax(svfloat32x4_t_val, svfloat32_t_val); + svmax(svfloat32x4_t_val, svfloat32x4_t_val); + svmax(svfloat64x2_t_val, svfloat64_t_val); + svmax(svfloat64x2_t_val, svfloat64x2_t_val); + svmax(svfloat64x4_t_val, svfloat64_t_val); + svmax(svfloat64x4_t_val, svfloat64x4_t_val); + svmax(svint8x2_t_val, svint8_t_val); + svmax(svint8x2_t_val, svint8x2_t_val); + svmax(svint8x4_t_val, svint8_t_val); + svmax(svint8x4_t_val, svint8x4_t_val); + svmax(svint16x2_t_val, svint16_t_val); + svmax(svint16x2_t_val, svint16x2_t_val); + svmax(svint16x4_t_val, svint16_t_val); + svmax(svint16x4_t_val, svint16x4_t_val); + svmax(svint32x2_t_val, svint32_t_val); + svmax(svint32x2_t_val, svint32x2_t_val); + svmax(svint32x4_t_val, svint32_t_val); + svmax(svint32x4_t_val, svint32x4_t_val); + svmax(svint64x2_t_val, svint64_t_val); + svmax(svint64x2_t_val, svint64x2_t_val); + svmax(svint64x4_t_val, svint64_t_val); + svmax(svint64x4_t_val, svint64x4_t_val); + svmax(svuint8x2_t_val, svuint8_t_val); + svmax(svuint8x2_t_val, svuint8x2_t_val); + svmax(svuint8x4_t_val, svuint8_t_val); + svmax(svuint8x4_t_val, svuint8x4_t_val); + svmax(svuint16x2_t_val, svuint16_t_val); + svmax(svuint16x2_t_val, svuint16x2_t_val); + svmax(svuint16x4_t_val, svuint16_t_val); + svmax(svuint16x4_t_val, svuint16x4_t_val); + svmax(svuint32x2_t_val, svuint32_t_val); + svmax(svuint32x2_t_val, svuint32x2_t_val); + svmax(svuint32x4_t_val, svuint32_t_val); + svmax(svuint32x4_t_val, svuint32x4_t_val); + svmax(svuint64x2_t_val, svuint64_t_val); + svmax(svuint64x2_t_val, svuint64x2_t_val); + svmax(svuint64x4_t_val, svuint64_t_val); + svmax(svuint64x4_t_val, svuint64x4_t_val); + svmax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svmax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svmax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svmax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svmax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svmax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + svmax_s8_x2(svint8x2_t_val, svint8x2_t_val); + svmax_s8_x4(svint8x4_t_val, svint8x4_t_val); + svmax_s16_x2(svint16x2_t_val, svint16x2_t_val); + svmax_s16_x4(svint16x4_t_val, svint16x4_t_val); + svmax_s32_x2(svint32x2_t_val, svint32x2_t_val); + svmax_s32_x4(svint32x4_t_val, svint32x4_t_val); + svmax_s64_x2(svint64x2_t_val, svint64x2_t_val); + svmax_s64_x4(svint64x4_t_val, svint64x4_t_val); + svmax_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + svmax_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + svmax_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + svmax_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + svmax_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + svmax_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + svmax_single_s8_x2(svint8x2_t_val, svint8_t_val); + svmax_single_s8_x4(svint8x4_t_val, svint8_t_val); + svmax_single_s16_x2(svint16x2_t_val, svint16_t_val); + svmax_single_s16_x4(svint16x4_t_val, svint16_t_val); + svmax_single_s32_x2(svint32x2_t_val, svint32_t_val); + svmax_single_s32_x4(svint32x4_t_val, svint32_t_val); + svmax_single_s64_x2(svint64x2_t_val, svint64_t_val); + svmax_single_s64_x4(svint64x4_t_val, svint64_t_val); + svmax_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + svmax_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + svmax_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + svmax_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + svmax_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + svmax_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + svmax_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + svmax_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + svmax_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + svmax_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + svmax_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + svmax_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + svmax_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + svmax_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + svmax_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + svmax_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + svmaxnm(svfloat16x2_t_val, svfloat16_t_val); + svmaxnm(svfloat16x2_t_val, svfloat16x2_t_val); + svmaxnm(svfloat16x4_t_val, svfloat16_t_val); + svmaxnm(svfloat16x4_t_val, svfloat16x4_t_val); + svmaxnm(svfloat32x2_t_val, svfloat32_t_val); + svmaxnm(svfloat32x2_t_val, svfloat32x2_t_val); + svmaxnm(svfloat32x4_t_val, svfloat32_t_val); + svmaxnm(svfloat32x4_t_val, svfloat32x4_t_val); + svmaxnm(svfloat64x2_t_val, svfloat64_t_val); + svmaxnm(svfloat64x2_t_val, svfloat64x2_t_val); + svmaxnm(svfloat64x4_t_val, svfloat64_t_val); + svmaxnm(svfloat64x4_t_val, svfloat64x4_t_val); + svmaxnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svmaxnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svmaxnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svmaxnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svmaxnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svmaxnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + svmaxnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + svmaxnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + svmaxnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + svmaxnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + svmaxnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + svmaxnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + svmin(svfloat16x2_t_val, svfloat16_t_val); + svmin(svfloat16x2_t_val, svfloat16x2_t_val); + svmin(svfloat16x4_t_val, svfloat16_t_val); + svmin(svfloat16x4_t_val, svfloat16x4_t_val); + svmin(svfloat32x2_t_val, svfloat32_t_val); + svmin(svfloat32x2_t_val, svfloat32x2_t_val); + svmin(svfloat32x4_t_val, svfloat32_t_val); + svmin(svfloat32x4_t_val, svfloat32x4_t_val); + svmin(svfloat64x2_t_val, svfloat64_t_val); + svmin(svfloat64x2_t_val, svfloat64x2_t_val); + svmin(svfloat64x4_t_val, svfloat64_t_val); + svmin(svfloat64x4_t_val, svfloat64x4_t_val); + svmin(svint8x2_t_val, svint8_t_val); + svmin(svint8x2_t_val, svint8x2_t_val); + svmin(svint8x4_t_val, svint8_t_val); + svmin(svint8x4_t_val, svint8x4_t_val); + svmin(svint16x2_t_val, svint16_t_val); + svmin(svint16x2_t_val, svint16x2_t_val); + svmin(svint16x4_t_val, svint16_t_val); + svmin(svint16x4_t_val, svint16x4_t_val); + svmin(svint32x2_t_val, svint32_t_val); + svmin(svint32x2_t_val, svint32x2_t_val); + svmin(svint32x4_t_val, svint32_t_val); + svmin(svint32x4_t_val, svint32x4_t_val); + svmin(svint64x2_t_val, svint64_t_val); + svmin(svint64x2_t_val, svint64x2_t_val); + svmin(svint64x4_t_val, svint64_t_val); + svmin(svint64x4_t_val, svint64x4_t_val); + svmin(svuint8x2_t_val, svuint8_t_val); + svmin(svuint8x2_t_val, svuint8x2_t_val); + svmin(svuint8x4_t_val, svuint8_t_val); + svmin(svuint8x4_t_val, svuint8x4_t_val); + svmin(svuint16x2_t_val, svuint16_t_val); + svmin(svuint16x2_t_val, svuint16x2_t_val); + svmin(svuint16x4_t_val, svuint16_t_val); + svmin(svuint16x4_t_val, svuint16x4_t_val); + svmin(svuint32x2_t_val, svuint32_t_val); + svmin(svuint32x2_t_val, svuint32x2_t_val); + svmin(svuint32x4_t_val, svuint32_t_val); + svmin(svuint32x4_t_val, svuint32x4_t_val); + svmin(svuint64x2_t_val, svuint64_t_val); + svmin(svuint64x2_t_val, svuint64x2_t_val); + svmin(svuint64x4_t_val, svuint64_t_val); + svmin(svuint64x4_t_val, svuint64x4_t_val); + svmin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svmin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svmin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svmin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svmin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svmin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + svmin_s8_x2(svint8x2_t_val, svint8x2_t_val); + svmin_s8_x4(svint8x4_t_val, svint8x4_t_val); + svmin_s16_x2(svint16x2_t_val, svint16x2_t_val); + svmin_s16_x4(svint16x4_t_val, svint16x4_t_val); + svmin_s32_x2(svint32x2_t_val, svint32x2_t_val); + svmin_s32_x4(svint32x4_t_val, svint32x4_t_val); + svmin_s64_x2(svint64x2_t_val, svint64x2_t_val); + svmin_s64_x4(svint64x4_t_val, svint64x4_t_val); + svmin_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + svmin_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + svmin_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + svmin_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + svmin_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + svmin_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + svmin_single_s8_x2(svint8x2_t_val, svint8_t_val); + svmin_single_s8_x4(svint8x4_t_val, svint8_t_val); + svmin_single_s16_x2(svint16x2_t_val, svint16_t_val); + svmin_single_s16_x4(svint16x4_t_val, svint16_t_val); + svmin_single_s32_x2(svint32x2_t_val, svint32_t_val); + svmin_single_s32_x4(svint32x4_t_val, svint32_t_val); + svmin_single_s64_x2(svint64x2_t_val, svint64_t_val); + svmin_single_s64_x4(svint64x4_t_val, svint64_t_val); + svmin_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + svmin_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + svmin_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + svmin_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + svmin_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + svmin_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + svmin_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + svmin_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + svmin_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + svmin_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + svmin_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + svmin_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + svmin_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + svmin_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + svmin_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + svmin_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + svminnm(svfloat16x2_t_val, svfloat16_t_val); + svminnm(svfloat16x2_t_val, svfloat16x2_t_val); + svminnm(svfloat16x4_t_val, svfloat16_t_val); + svminnm(svfloat16x4_t_val, svfloat16x4_t_val); + svminnm(svfloat32x2_t_val, svfloat32_t_val); + svminnm(svfloat32x2_t_val, svfloat32x2_t_val); + svminnm(svfloat32x4_t_val, svfloat32_t_val); + svminnm(svfloat32x4_t_val, svfloat32x4_t_val); + svminnm(svfloat64x2_t_val, svfloat64_t_val); + svminnm(svfloat64x2_t_val, svfloat64x2_t_val); + svminnm(svfloat64x4_t_val, svfloat64_t_val); + svminnm(svfloat64x4_t_val, svfloat64x4_t_val); + svminnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svminnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svminnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svminnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svminnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svminnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + svminnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + svminnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + svminnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + svminnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + svminnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + svminnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + svqcvt_s8(svint32x4_t_val); + svqcvt_s8_s32_x4(svint32x4_t_val); + svqcvt_s16(svint32x2_t_val); + svqcvt_s16(svint64x4_t_val); + svqcvt_s16_s32_x2(svint32x2_t_val); + svqcvt_s16_s64_x4(svint64x4_t_val); + svqcvt_u8(svint32x4_t_val); + svqcvt_u8(svuint32x4_t_val); + svqcvt_u8_s32_x4(svint32x4_t_val); + svqcvt_u8_u32_x4(svuint32x4_t_val); + svqcvt_u16(svint32x2_t_val); + svqcvt_u16(svint64x4_t_val); + svqcvt_u16(svuint32x2_t_val); + svqcvt_u16(svuint64x4_t_val); + svqcvt_u16_s32_x2(svint32x2_t_val); + svqcvt_u16_s64_x4(svint64x4_t_val); + svqcvt_u16_u32_x2(svuint32x2_t_val); + svqcvt_u16_u64_x4(svuint64x4_t_val); + svqcvtn_s8(svint32x4_t_val); + svqcvtn_s8_s32_x4(svint32x4_t_val); + svqcvtn_s16(svint64x4_t_val); + svqcvtn_s16_s64_x4(svint64x4_t_val); + svqcvtn_u8(svint32x4_t_val); + svqcvtn_u8(svuint32x4_t_val); + svqcvtn_u8_s32_x4(svint32x4_t_val); + svqcvtn_u8_u32_x4(svuint32x4_t_val); + svqcvtn_u16(svint64x4_t_val); + svqcvtn_u16(svuint64x4_t_val); + svqcvtn_u16_s64_x4(svint64x4_t_val); + svqcvtn_u16_u64_x4(svuint64x4_t_val); + svqdmulh(svint8x2_t_val, svint8_t_val); + svqdmulh(svint8x2_t_val, svint8x2_t_val); + svqdmulh(svint8x4_t_val, svint8_t_val); + svqdmulh(svint8x4_t_val, svint8x4_t_val); + svqdmulh(svint16x2_t_val, svint16_t_val); + svqdmulh(svint16x2_t_val, svint16x2_t_val); + svqdmulh(svint16x4_t_val, svint16_t_val); + svqdmulh(svint16x4_t_val, svint16x4_t_val); + svqdmulh(svint32x2_t_val, svint32_t_val); + svqdmulh(svint32x2_t_val, svint32x2_t_val); + svqdmulh(svint32x4_t_val, svint32_t_val); + svqdmulh(svint32x4_t_val, svint32x4_t_val); + svqdmulh(svint64x2_t_val, svint64_t_val); + svqdmulh(svint64x2_t_val, svint64x2_t_val); + svqdmulh(svint64x4_t_val, svint64_t_val); + svqdmulh(svint64x4_t_val, svint64x4_t_val); + svqdmulh_s8_x2(svint8x2_t_val, svint8x2_t_val); + svqdmulh_s8_x4(svint8x4_t_val, svint8x4_t_val); + svqdmulh_s16_x2(svint16x2_t_val, svint16x2_t_val); + svqdmulh_s16_x4(svint16x4_t_val, svint16x4_t_val); + svqdmulh_s32_x2(svint32x2_t_val, svint32x2_t_val); + svqdmulh_s32_x4(svint32x4_t_val, svint32x4_t_val); + svqdmulh_s64_x2(svint64x2_t_val, svint64x2_t_val); + svqdmulh_s64_x4(svint64x4_t_val, svint64x4_t_val); + svqdmulh_single_s8_x2(svint8x2_t_val, svint8_t_val); + svqdmulh_single_s8_x4(svint8x4_t_val, svint8_t_val); + svqdmulh_single_s16_x2(svint16x2_t_val, svint16_t_val); + svqdmulh_single_s16_x4(svint16x4_t_val, svint16_t_val); + svqdmulh_single_s32_x2(svint32x2_t_val, svint32_t_val); + svqdmulh_single_s32_x4(svint32x4_t_val, svint32_t_val); + svqdmulh_single_s64_x2(svint64x2_t_val, svint64_t_val); + svqdmulh_single_s64_x4(svint64x4_t_val, svint64_t_val); + svqrshr_n_s8_s32_x4(svint32x4_t_val, 2); + svqrshr_n_s16_s32_x2(svint32x2_t_val, 2); + svqrshr_n_s16_s64_x4(svint64x4_t_val, 2); + svqrshr_n_u8_u32_x4(svuint32x4_t_val, 2); + svqrshr_n_u16_u32_x2(svuint32x2_t_val, 2); + svqrshr_n_u16_u64_x4(svuint64x4_t_val, 2); + svqrshr_s8(svint32x4_t_val, 2); + svqrshr_s16(svint32x2_t_val, 2); + svqrshr_s16(svint64x4_t_val, 2); + svqrshr_u8(svuint32x4_t_val, 2); + svqrshr_u16(svuint32x2_t_val, 2); + svqrshr_u16(svuint64x4_t_val, 2); + svqrshrn_n_s8_s32_x4(svint32x4_t_val, 2); + svqrshrn_n_s16_s64_x4(svint64x4_t_val, 2); + svqrshrn_n_u8_u32_x4(svuint32x4_t_val, 2); + svqrshrn_n_u16_u64_x4(svuint64x4_t_val, 2); + svqrshrn_s8(svint32x4_t_val, 2); + svqrshrn_s16(svint64x4_t_val, 2); + svqrshrn_u8(svuint32x4_t_val, 2); + svqrshrn_u16(svuint64x4_t_val, 2); + svqrshru_n_u8_s32_x4(svint32x4_t_val, 2); + svqrshru_n_u16_s32_x2(svint32x2_t_val, 2); + svqrshru_n_u16_s64_x4(svint64x4_t_val, 2); + svqrshru_u8(svint32x4_t_val, 2); + svqrshru_u16(svint32x2_t_val, 2); + svqrshru_u16(svint64x4_t_val, 2); + svqrshrun_n_u8_s32_x4(svint32x4_t_val, 2); + svqrshrun_n_u16_s64_x4(svint64x4_t_val, 2); + svqrshrun_u8(svint32x4_t_val, 2); + svqrshrun_u16(svint64x4_t_val, 2); + svrinta(svfloat32x2_t_val); + svrinta(svfloat32x4_t_val); + svrinta_f32_x2(svfloat32x2_t_val); + svrinta_f32_x4(svfloat32x4_t_val); + svrintm(svfloat32x2_t_val); + svrintm(svfloat32x4_t_val); + svrintm_f32_x2(svfloat32x2_t_val); + svrintm_f32_x4(svfloat32x4_t_val); + svrintn(svfloat32x2_t_val); + svrintn(svfloat32x4_t_val); + svrintn_f32_x2(svfloat32x2_t_val); + svrintn_f32_x4(svfloat32x4_t_val); + svrintp(svfloat32x2_t_val); + svrintp(svfloat32x4_t_val); + svrintp_f32_x2(svfloat32x2_t_val); + svrintp_f32_x4(svfloat32x4_t_val); + svrshl(svint8x2_t_val, svint8_t_val); + svrshl(svint8x2_t_val, svint8x2_t_val); + svrshl(svint8x4_t_val, svint8_t_val); + svrshl(svint8x4_t_val, svint8x4_t_val); + svrshl(svint16x2_t_val, svint16_t_val); + svrshl(svint16x2_t_val, svint16x2_t_val); + svrshl(svint16x4_t_val, svint16_t_val); + svrshl(svint16x4_t_val, svint16x4_t_val); + svrshl(svint32x2_t_val, svint32_t_val); + svrshl(svint32x2_t_val, svint32x2_t_val); + svrshl(svint32x4_t_val, svint32_t_val); + svrshl(svint32x4_t_val, svint32x4_t_val); + svrshl(svint64x2_t_val, svint64_t_val); + svrshl(svint64x2_t_val, svint64x2_t_val); + svrshl(svint64x4_t_val, svint64_t_val); + svrshl(svint64x4_t_val, svint64x4_t_val); + svrshl(svuint8x2_t_val, svuint8_t_val); + svrshl(svuint8x2_t_val, svuint8x2_t_val); + svrshl(svuint8x4_t_val, svuint8_t_val); + svrshl(svuint8x4_t_val, svuint8x4_t_val); + svrshl(svuint16x2_t_val, svuint16_t_val); + svrshl(svuint16x2_t_val, svuint16x2_t_val); + svrshl(svuint16x4_t_val, svuint16_t_val); + svrshl(svuint16x4_t_val, svuint16x4_t_val); + svrshl(svuint32x2_t_val, svuint32_t_val); + svrshl(svuint32x2_t_val, svuint32x2_t_val); + svrshl(svuint32x4_t_val, svuint32_t_val); + svrshl(svuint32x4_t_val, svuint32x4_t_val); + svrshl(svuint64x2_t_val, svuint64_t_val); + svrshl(svuint64x2_t_val, svuint64x2_t_val); + svrshl(svuint64x4_t_val, svuint64_t_val); + svrshl(svuint64x4_t_val, svuint64x4_t_val); + svrshl_s8_x2(svint8x2_t_val, svint8x2_t_val); + svrshl_s8_x4(svint8x4_t_val, svint8x4_t_val); + svrshl_s16_x2(svint16x2_t_val, svint16x2_t_val); + svrshl_s16_x4(svint16x4_t_val, svint16x4_t_val); + svrshl_s32_x2(svint32x2_t_val, svint32x2_t_val); + svrshl_s32_x4(svint32x4_t_val, svint32x4_t_val); + svrshl_s64_x2(svint64x2_t_val, svint64x2_t_val); + svrshl_s64_x4(svint64x4_t_val, svint64x4_t_val); + svrshl_single_s8_x2(svint8x2_t_val, svint8_t_val); + svrshl_single_s8_x4(svint8x4_t_val, svint8_t_val); + svrshl_single_s16_x2(svint16x2_t_val, svint16_t_val); + svrshl_single_s16_x4(svint16x4_t_val, svint16_t_val); + svrshl_single_s32_x2(svint32x2_t_val, svint32_t_val); + svrshl_single_s32_x4(svint32x4_t_val, svint32_t_val); + svrshl_single_s64_x2(svint64x2_t_val, svint64_t_val); + svrshl_single_s64_x4(svint64x4_t_val, svint64_t_val); + svrshl_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + svrshl_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + svrshl_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + svrshl_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + svrshl_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + svrshl_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + svrshl_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + svrshl_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + svrshl_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + svrshl_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + svrshl_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + svrshl_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + svrshl_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + svrshl_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + svrshl_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + svrshl_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + svsel(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svsel(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svsel(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svsel(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svsel(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + svsel(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + svsel(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svsel(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svsel(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + svsel(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + svsel(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + svsel(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + svsel(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + svsel(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + svsel(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + svsel(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + svsel(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + svsel(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + svsel(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + svsel(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + svsel(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + svsel(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + svsel(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + svsel(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + svsel(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + svsel(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + svsel_bf16_x2(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + svsel_bf16_x4(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + svsel_f16_x2(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + svsel_f16_x4(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + svsel_f32_x2(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + svsel_f32_x4(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + svsel_f64_x2(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + svsel_f64_x4(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + svsel_mf8_x2(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + svsel_mf8_x4(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + svsel_s8_x2(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + svsel_s8_x4(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + svsel_s16_x2(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + svsel_s16_x4(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + svsel_s32_x2(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + svsel_s32_x4(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + svsel_s64_x2(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + svsel_s64_x4(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + svsel_u8_x2(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + svsel_u8_x4(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + svsel_u16_x2(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + svsel_u16_x4(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + svsel_u32_x2(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + svsel_u32_x4(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + svsel_u64_x2(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + svsel_u64_x4(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + svunpk_s16(svint8_t_val); + svunpk_s16(svint8x2_t_val); + svunpk_s16_s8_x2(svint8_t_val); + svunpk_s16_s8_x4(svint8x2_t_val); + svunpk_s32(svint16_t_val); + svunpk_s32(svint16x2_t_val); + svunpk_s32_s16_x2(svint16_t_val); + svunpk_s32_s16_x4(svint16x2_t_val); + svunpk_s64(svint32_t_val); + svunpk_s64(svint32x2_t_val); + svunpk_s64_s32_x2(svint32_t_val); + svunpk_s64_s32_x4(svint32x2_t_val); + svunpk_u16(svuint8_t_val); + svunpk_u16(svuint8x2_t_val); + svunpk_u16_u8_x2(svuint8_t_val); + svunpk_u16_u8_x4(svuint8x2_t_val); + svunpk_u32(svuint16_t_val); + svunpk_u32(svuint16x2_t_val); + svunpk_u32_u16_x2(svuint16_t_val); + svunpk_u32_u16_x4(svuint16x2_t_val); + svunpk_u64(svuint32_t_val); + svunpk_u64(svuint32x2_t_val); + svunpk_u64_u32_x2(svuint32_t_val); + svunpk_u64_u32_x4(svuint32x2_t_val); + svuzp(svbfloat16x2_t_val); + svuzp(svbfloat16x4_t_val); + svuzp(svfloat16x2_t_val); + svuzp(svfloat16x4_t_val); + svuzp(svfloat32x2_t_val); + svuzp(svfloat32x4_t_val); + svuzp(svfloat64x2_t_val); + svuzp(svfloat64x4_t_val); + svuzp(svint8x2_t_val); + svuzp(svint8x4_t_val); + svuzp(svint16x2_t_val); + svuzp(svint16x4_t_val); + svuzp(svint32x2_t_val); + svuzp(svint32x4_t_val); + svuzp(svint64x2_t_val); + svuzp(svint64x4_t_val); + svuzp(svmfloat8x2_t_val); + svuzp(svmfloat8x4_t_val); + svuzp(svuint8x2_t_val); + svuzp(svuint8x4_t_val); + svuzp(svuint16x2_t_val); + svuzp(svuint16x4_t_val); + svuzp(svuint32x2_t_val); + svuzp(svuint32x4_t_val); + svuzp(svuint64x2_t_val); + svuzp(svuint64x4_t_val); + svuzp_bf16_x2(svbfloat16x2_t_val); + svuzp_bf16_x4(svbfloat16x4_t_val); + svuzp_f16_x2(svfloat16x2_t_val); + svuzp_f16_x4(svfloat16x4_t_val); + svuzp_f32_x2(svfloat32x2_t_val); + svuzp_f32_x4(svfloat32x4_t_val); + svuzp_f64_x2(svfloat64x2_t_val); + svuzp_f64_x4(svfloat64x4_t_val); + svuzp_mf8_x2(svmfloat8x2_t_val); + svuzp_mf8_x4(svmfloat8x4_t_val); + svuzp_s8_x2(svint8x2_t_val); + svuzp_s8_x4(svint8x4_t_val); + svuzp_s16_x2(svint16x2_t_val); + svuzp_s16_x4(svint16x4_t_val); + svuzp_s32_x2(svint32x2_t_val); + svuzp_s32_x4(svint32x4_t_val); + svuzp_s64_x2(svint64x2_t_val); + svuzp_s64_x4(svint64x4_t_val); + svuzp_u8_x2(svuint8x2_t_val); + svuzp_u8_x4(svuint8x4_t_val); + svuzp_u16_x2(svuint16x2_t_val); + svuzp_u16_x4(svuint16x4_t_val); + svuzp_u32_x2(svuint32x2_t_val); + svuzp_u32_x4(svuint32x4_t_val); + svuzp_u64_x2(svuint64x2_t_val); + svuzp_u64_x4(svuint64x4_t_val); + svuzpq(svbfloat16x2_t_val); + svuzpq(svbfloat16x4_t_val); + svuzpq(svfloat16x2_t_val); + svuzpq(svfloat16x4_t_val); + svuzpq(svfloat32x2_t_val); + svuzpq(svfloat32x4_t_val); + svuzpq(svfloat64x2_t_val); + svuzpq(svfloat64x4_t_val); + svuzpq(svint8x2_t_val); + svuzpq(svint8x4_t_val); + svuzpq(svint16x2_t_val); + svuzpq(svint16x4_t_val); + svuzpq(svint32x2_t_val); + svuzpq(svint32x4_t_val); + svuzpq(svint64x2_t_val); + svuzpq(svint64x4_t_val); + svuzpq(svmfloat8x2_t_val); + svuzpq(svmfloat8x4_t_val); + svuzpq(svuint8x2_t_val); + svuzpq(svuint8x4_t_val); + svuzpq(svuint16x2_t_val); + svuzpq(svuint16x4_t_val); + svuzpq(svuint32x2_t_val); + svuzpq(svuint32x4_t_val); + svuzpq(svuint64x2_t_val); + svuzpq(svuint64x4_t_val); + svuzpq_bf16_x2(svbfloat16x2_t_val); + svuzpq_bf16_x4(svbfloat16x4_t_val); + svuzpq_f16_x2(svfloat16x2_t_val); + svuzpq_f16_x4(svfloat16x4_t_val); + svuzpq_f32_x2(svfloat32x2_t_val); + svuzpq_f32_x4(svfloat32x4_t_val); + svuzpq_f64_x2(svfloat64x2_t_val); + svuzpq_f64_x4(svfloat64x4_t_val); + svuzpq_mf8_x2(svmfloat8x2_t_val); + svuzpq_mf8_x4(svmfloat8x4_t_val); + svuzpq_s8_x2(svint8x2_t_val); + svuzpq_s8_x4(svint8x4_t_val); + svuzpq_s16_x2(svint16x2_t_val); + svuzpq_s16_x4(svint16x4_t_val); + svuzpq_s32_x2(svint32x2_t_val); + svuzpq_s32_x4(svint32x4_t_val); + svuzpq_s64_x2(svint64x2_t_val); + svuzpq_s64_x4(svint64x4_t_val); + svuzpq_u8_x2(svuint8x2_t_val); + svuzpq_u8_x4(svuint8x4_t_val); + svuzpq_u16_x2(svuint16x2_t_val); + svuzpq_u16_x4(svuint16x4_t_val); + svuzpq_u32_x2(svuint32x2_t_val); + svuzpq_u32_x4(svuint32x4_t_val); + svuzpq_u64_x2(svuint64x2_t_val); + svuzpq_u64_x4(svuint64x4_t_val); + svzip(svbfloat16x2_t_val); + svzip(svbfloat16x4_t_val); + svzip(svfloat16x2_t_val); + svzip(svfloat16x4_t_val); + svzip(svfloat32x2_t_val); + svzip(svfloat32x4_t_val); + svzip(svfloat64x2_t_val); + svzip(svfloat64x4_t_val); + svzip(svint8x2_t_val); + svzip(svint8x4_t_val); + svzip(svint16x2_t_val); + svzip(svint16x4_t_val); + svzip(svint32x2_t_val); + svzip(svint32x4_t_val); + svzip(svint64x2_t_val); + svzip(svint64x4_t_val); + svzip(svmfloat8x2_t_val); + svzip(svmfloat8x4_t_val); + svzip(svuint8x2_t_val); + svzip(svuint8x4_t_val); + svzip(svuint16x2_t_val); + svzip(svuint16x4_t_val); + svzip(svuint32x2_t_val); + svzip(svuint32x4_t_val); + svzip(svuint64x2_t_val); + svzip(svuint64x4_t_val); + svzip_bf16_x2(svbfloat16x2_t_val); + svzip_bf16_x4(svbfloat16x4_t_val); + svzip_f16_x2(svfloat16x2_t_val); + svzip_f16_x4(svfloat16x4_t_val); + svzip_f32_x2(svfloat32x2_t_val); + svzip_f32_x4(svfloat32x4_t_val); + svzip_f64_x2(svfloat64x2_t_val); + svzip_f64_x4(svfloat64x4_t_val); + svzip_mf8_x2(svmfloat8x2_t_val); + svzip_mf8_x4(svmfloat8x4_t_val); + svzip_s8_x2(svint8x2_t_val); + svzip_s8_x4(svint8x4_t_val); + svzip_s16_x2(svint16x2_t_val); + svzip_s16_x4(svint16x4_t_val); + svzip_s32_x2(svint32x2_t_val); + svzip_s32_x4(svint32x4_t_val); + svzip_s64_x2(svint64x2_t_val); + svzip_s64_x4(svint64x4_t_val); + svzip_u8_x2(svuint8x2_t_val); + svzip_u8_x4(svuint8x4_t_val); + svzip_u16_x2(svuint16x2_t_val); + svzip_u16_x4(svuint16x4_t_val); + svzip_u32_x2(svuint32x2_t_val); + svzip_u32_x4(svuint32x4_t_val); + svzip_u64_x2(svuint64x2_t_val); + svzip_u64_x4(svuint64x4_t_val); + svzipq(svbfloat16x2_t_val); + svzipq(svbfloat16x4_t_val); + svzipq(svfloat16x2_t_val); + svzipq(svfloat16x4_t_val); + svzipq(svfloat32x2_t_val); + svzipq(svfloat32x4_t_val); + svzipq(svfloat64x2_t_val); + svzipq(svfloat64x4_t_val); + svzipq(svint8x2_t_val); + svzipq(svint8x4_t_val); + svzipq(svint16x2_t_val); + svzipq(svint16x4_t_val); + svzipq(svint32x2_t_val); + svzipq(svint32x4_t_val); + svzipq(svint64x2_t_val); + svzipq(svint64x4_t_val); + svzipq(svmfloat8x2_t_val); + svzipq(svmfloat8x4_t_val); + svzipq(svuint8x2_t_val); + svzipq(svuint8x4_t_val); + svzipq(svuint16x2_t_val); + svzipq(svuint16x4_t_val); + svzipq(svuint32x2_t_val); + svzipq(svuint32x4_t_val); + svzipq(svuint64x2_t_val); + svzipq(svuint64x4_t_val); + svzipq_bf16_x2(svbfloat16x2_t_val); + svzipq_bf16_x4(svbfloat16x4_t_val); + svzipq_f16_x2(svfloat16x2_t_val); + svzipq_f16_x4(svfloat16x4_t_val); + svzipq_f32_x2(svfloat32x2_t_val); + svzipq_f32_x4(svfloat32x4_t_val); + svzipq_f64_x2(svfloat64x2_t_val); + svzipq_f64_x4(svfloat64x4_t_val); + svzipq_mf8_x2(svmfloat8x2_t_val); + svzipq_mf8_x4(svmfloat8x4_t_val); + svzipq_s8_x2(svint8x2_t_val); + svzipq_s8_x4(svint8x4_t_val); + svzipq_s16_x2(svint16x2_t_val); + svzipq_s16_x4(svint16x4_t_val); + svzipq_s32_x2(svint32x2_t_val); + svzipq_s32_x4(svint32x4_t_val); + svzipq_s64_x2(svint64x2_t_val); + svzipq_s64_x4(svint64x4_t_val); + svzipq_u8_x2(svuint8x2_t_val); + svzipq_u8_x4(svuint8x4_t_val); + svzipq_u16_x2(svuint16x2_t_val); + svzipq_u16_x4(svuint16x4_t_val); + svzipq_u32_x2(svuint32x2_t_val); + svzipq_u32_x4(svuint32x4_t_val); + svzipq_u64_x2(svuint64x2_t_val); + svzipq_u64_x4(svuint64x4_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + svcount_t svcount_t_val; + svfloat16_t svfloat16_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32_t svfloat32_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64_t svfloat64_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint8_t svint8_t_val; + svint8x2_t svint8x2_t_val; + svint8x4_t svint8x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8x2_t svmfloat8x2_t_val; + svmfloat8x4_t svmfloat8x4_t_val; + svuint8_t svuint8_t_val; + svuint8x2_t svuint8x2_t_val; + svuint8x4_t svuint8x4_t_val; + svuint16_t svuint16_t_val; + svuint16x2_t svuint16x2_t_val; + svuint16x4_t svuint16x4_t_val; + svuint32_t svuint32_t_val; + svuint32x2_t svuint32x2_t_val; + svuint32x4_t svuint32x4_t_val; + svuint64_t svuint64_t_val; + svuint64x2_t svuint64x2_t_val; + svuint64x4_t svuint64x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svadd_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint8x2_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint8x4_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint16x2_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint16x4_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint32x2_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint32x4_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint64x2_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svint64x4_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s8_x2(svint8x2_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s8_x4(svint8x4_t_val, svint8_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s16_x2(svint16x2_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s16_x4(svint16x4_t_val, svint16_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s32_x2(svint32x2_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s32_x4(svint32x4_t_val, svint32_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s64_x2(svint64x2_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_s64_x4(svint64x4_t_val, svint64_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u8_x2(svuint8x2_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u8_x4(svuint8x4_t_val, svuint8_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u16_x2(svuint16x2_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u16_x4(svuint16x4_t_val, svuint16_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u32_x2(svuint32x2_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u32_x4(svuint32x4_t_val, svuint32_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u64_x2(svuint64x2_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_u64_x4(svuint64x4_t_val, svuint64_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_bf16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_bf16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_f32_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_s32_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_u32_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_bf16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_bf16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_f16(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_f16_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f16_x2(svfloat16x2_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f16_x4(svfloat16x4_t_val, svfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f32_x2(svfloat32x2_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f32_x4(svfloat32x4_t_val, svfloat32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f64_x2(svfloat64x2_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_f64_x4(svfloat64x4_t_val, svfloat64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_s16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u8_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvt_u16_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_s16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u8_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqcvtn_u16_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqdmulh_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s16_s32_x2(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_s16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u8_u32_x4(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u16_u32_x2(svuint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_n_u16_u64_x4(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s16(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_s16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u8(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u16(svuint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshr_u16(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_s8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_s16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_u8_u32_x4(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_n_u16_u64_x4(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_s8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_s16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_u8(svuint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrn_u16(svuint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u16_s32_x2(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_n_u16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u16(svint32x2_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshru_u16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_n_u8_s32_x4(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_n_u16_s64_x4(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_u8(svint32x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svqrshrun_u16(svint64x4_t_val, 2); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrinta_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintm_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintn_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrintp_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x2(svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s8_x4(svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x2(svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s16_x4(svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x2(svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s32_x4(svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x2(svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_s64_x4(svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s8_x2(svint8x2_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s8_x4(svint8x4_t_val, svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s16_x2(svint16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s16_x4(svint16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s32_x2(svint32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s32_x4(svint32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s64_x2(svint64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_s64_x4(svint64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u8_x2(svuint8x2_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u8_x4(svuint8x4_t_val, svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u16_x2(svuint16x2_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u16_x4(svuint16x4_t_val, svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u32_x2(svuint32x2_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u32_x4(svuint32x4_t_val, svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u64_x2(svuint64x2_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_single_u64_x4(svuint64x4_t_val, svuint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x2(svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u8_x4(svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x2(svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u16_x4(svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x2(svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u32_x4(svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x2(svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svrshl_u64_x4(svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_bf16_x2(svcount_t_val, svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_bf16_x4(svcount_t_val, svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f16_x2(svcount_t_val, svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f16_x4(svcount_t_val, svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f32_x2(svcount_t_val, svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f32_x4(svcount_t_val, svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f64_x2(svcount_t_val, svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_f64_x4(svcount_t_val, svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_mf8_x2(svcount_t_val, svmfloat8x2_t_val, svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_mf8_x4(svcount_t_val, svmfloat8x4_t_val, svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s8_x2(svcount_t_val, svint8x2_t_val, svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s8_x4(svcount_t_val, svint8x4_t_val, svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s16_x2(svcount_t_val, svint16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s16_x4(svcount_t_val, svint16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s32_x2(svcount_t_val, svint32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s32_x4(svcount_t_val, svint32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s64_x2(svcount_t_val, svint64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_s64_x4(svcount_t_val, svint64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u8_x2(svcount_t_val, svuint8x2_t_val, svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u8_x4(svcount_t_val, svuint8x4_t_val, svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u16_x2(svcount_t_val, svuint16x2_t_val, svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u16_x4(svcount_t_val, svuint16x4_t_val, svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u32_x2(svcount_t_val, svuint32x2_t_val, svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u32_x4(svcount_t_val, svuint32x4_t_val, svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u64_x2(svcount_t_val, svuint64x2_t_val, svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svsel_u64_x4(svcount_t_val, svuint64x4_t_val, svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16_s8_x2(svint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s16_s8_x4(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32_s16_x2(svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s32_s16_x4(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64_s32_x2(svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_s64_s32_x4(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16_u8_x2(svuint8_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u16_u8_x4(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32_u16_x2(svuint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u32_u16_x4(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64_u32_x2(svuint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svunpk_u64_u32_x4(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzp_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svuzpq_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzip_u64_x4(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq(svuint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_bf16_x2(svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_bf16_x4(svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f16_x2(svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f16_x4(svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f32_x2(svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f32_x4(svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f64_x2(svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_f64_x4(svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_mf8_x2(svmfloat8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_mf8_x4(svmfloat8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s8_x2(svint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s8_x4(svint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s16_x2(svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s16_x4(svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s32_x2(svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s32_x4(svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s64_x2(svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_s64_x4(svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u8_x2(svuint8x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u8_x4(svuint8x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u16_x2(svuint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u16_x4(svuint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u32_x2(svuint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u32_x4(svuint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u64_x2(svuint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svzipq_u64_x4(svuint64x4_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_faminmax.c b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_faminmax.c new file mode 100644 index 0000000..8ff336d --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_faminmax.c @@ -0,0 +1,158 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="" streaming_guard="sme,sme2,faminmax" flags="streaming-only" + +void test(void) { + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); +} + +void test_streaming(void) __arm_streaming{ + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + + svamax(svfloat16x2_t_val, svfloat16x2_t_val); + svamax(svfloat16x4_t_val, svfloat16x4_t_val); + svamax(svfloat32x2_t_val, svfloat32x2_t_val); + svamax(svfloat32x4_t_val, svfloat32x4_t_val); + svamax(svfloat64x2_t_val, svfloat64x2_t_val); + svamax(svfloat64x4_t_val, svfloat64x4_t_val); + svamax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svamax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svamax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svamax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svamax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svamax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + svamin(svfloat16x2_t_val, svfloat16x2_t_val); + svamin(svfloat16x4_t_val, svfloat16x4_t_val); + svamin(svfloat32x2_t_val, svfloat32x2_t_val); + svamin(svfloat32x4_t_val, svfloat32x4_t_val); + svamin(svfloat64x2_t_val, svfloat64x2_t_val); + svamin(svfloat64x4_t_val, svfloat64x4_t_val); + svamin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + svamin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + svamin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + svamin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + svamin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + svamin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamax_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin(svfloat64x4_t_val, svfloat64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x2(svfloat16x2_t_val, svfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f16_x4(svfloat16x4_t_val, svfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x2(svfloat32x2_t_val, svfloat32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f32_x4(svfloat32x4_t_val, svfloat32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x2(svfloat64x2_t_val, svfloat64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svamin_f64_x4(svfloat64x4_t_val, svfloat64x4_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_fp8.c b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_fp8.c new file mode 100644 index 0000000..97c5c3f --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_fp8.c @@ -0,0 +1,314 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="" streaming_guard="sme,sme2,fp8" flags="streaming-only" + +void test(void) { + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f16_x2(svfloat16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f16_x4(svfloat16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f32_x2(svfloat32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f32_x4(svfloat32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f64_x2(svfloat64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f64_x4(svfloat64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f16_x2(svfloat16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f16_x4(svfloat16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f32_x2(svfloat32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f32_x4(svfloat32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f64_x2(svfloat64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f64_x4(svfloat64x4_t_val, svint64_t_val); +} + +void test_streaming(void) __arm_streaming{ + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + + svcvt1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvt_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + svcvt_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + svcvt_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + svcvt_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + svcvt_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + svcvt_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + svcvtl1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtl2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + svcvtn_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + svcvtn_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + svscale(svfloat16x2_t_val, svint16_t_val); + svscale(svfloat16x2_t_val, svint16x2_t_val); + svscale(svfloat16x4_t_val, svint16_t_val); + svscale(svfloat16x4_t_val, svint16x4_t_val); + svscale(svfloat32x2_t_val, svint32_t_val); + svscale(svfloat32x2_t_val, svint32x2_t_val); + svscale(svfloat32x4_t_val, svint32_t_val); + svscale(svfloat32x4_t_val, svint32x4_t_val); + svscale(svfloat64x2_t_val, svint64_t_val); + svscale(svfloat64x2_t_val, svint64x2_t_val); + svscale(svfloat64x4_t_val, svint64_t_val); + svscale(svfloat64x4_t_val, svint64x4_t_val); + svscale_f16_x2(svfloat16x2_t_val, svint16x2_t_val); + svscale_f16_x4(svfloat16x4_t_val, svint16x4_t_val); + svscale_f32_x2(svfloat32x2_t_val, svint32x2_t_val); + svscale_f32_x4(svfloat32x4_t_val, svint32x4_t_val); + svscale_f64_x2(svfloat64x2_t_val, svint64x2_t_val); + svscale_f64_x4(svfloat64x4_t_val, svint64x4_t_val); + svscale_single_f16_x2(svfloat16x2_t_val, svint16_t_val); + svscale_single_f16_x4(svfloat16x4_t_val, svint16_t_val); + svscale_single_f32_x2(svfloat32x2_t_val, svint32_t_val); + svscale_single_f32_x4(svfloat32x4_t_val, svint32_t_val); + svscale_single_f64_x2(svfloat64x2_t_val, svint64_t_val); + svscale_single_f64_x4(svfloat64x4_t_val, svint64_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + fpm_t fpm_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svfloat16x2_t svfloat16x2_t_val; + svfloat16x4_t svfloat16x4_t_val; + svfloat32x2_t svfloat32x2_t_val; + svfloat32x4_t svfloat32x4_t_val; + svfloat64x2_t svfloat64x2_t_val; + svfloat64x4_t svfloat64x4_t_val; + svint16_t svint16_t_val; + svint16x2_t svint16x2_t_val; + svint16x4_t svint16x4_t_val; + svint32_t svint32_t_val; + svint32x2_t svint32x2_t_val; + svint32x4_t svint32x4_t_val; + svint64_t svint64_t_val; + svint64x2_t svint64x2_t_val; + svint64x4_t svint64x4_t_val; + svmfloat8_t svmfloat8_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_bf16_x2_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_f16_x2_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svbfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svfloat16x2_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvt_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl1_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_bf16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_bf16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_f16_mf8_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtl2_f16_x2_fpm(svmfloat8_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_f32_x4_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svcvtn_mf8_fpm(svfloat32x4_t_val, fpm_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x4_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale(svfloat64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f16_x2(svfloat16x2_t_val, svint16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f16_x4(svfloat16x4_t_val, svint16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f32_x2(svfloat32x2_t_val, svint32x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f32_x4(svfloat32x4_t_val, svint32x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f64_x2(svfloat64x2_t_val, svint64x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_f64_x4(svfloat64x4_t_val, svint64x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f16_x2(svfloat16x2_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f16_x4(svfloat16x4_t_val, svint16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f32_x2(svfloat32x2_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f32_x4(svfloat32x4_t_val, svint32_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f64_x2(svfloat64x2_t_val, svint64_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svscale_single_f64_x4(svfloat64x4_t_val, svint64_t_val); +} diff --git a/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_sve-b16b16.c b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_sve-b16b16.c new file mode 100644 index 0000000..4f1d3ad --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_streaming_only_sme_AND_sme2_AND_sve-b16b16.c @@ -0,0 +1,209 @@ +// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -target-feature +sme2 -target-feature +sve -target-feature +sve-b16b16 -verify=streaming-guard + +// REQUIRES: aarch64-registered-target + +#include <arm_sve.h> + +// Properties: guard="" streaming_guard="sme,sme2,sve-b16b16" flags="streaming-only" + +void test(void) { + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); +} + +void test_streaming(void) __arm_streaming{ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + + svclamp(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclamp(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclamp_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + svclamp_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + svmax(svbfloat16x2_t_val, svbfloat16_t_val); + svmax(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmax(svbfloat16x4_t_val, svbfloat16_t_val); + svmax(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmax_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmax_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmax_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + svmax_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + svmaxnm(svbfloat16x2_t_val, svbfloat16_t_val); + svmaxnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmaxnm(svbfloat16x4_t_val, svbfloat16_t_val); + svmaxnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmaxnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmaxnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmaxnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + svmaxnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + svmin(svbfloat16x2_t_val, svbfloat16_t_val); + svmin(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmin(svbfloat16x4_t_val, svbfloat16_t_val); + svmin(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmin_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + svmin_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + svmin_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + svmin_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + svminnm(svbfloat16x2_t_val, svbfloat16_t_val); + svminnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + svminnm(svbfloat16x4_t_val, svbfloat16_t_val); + svminnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + svminnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + svminnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + svminnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + svminnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); +} + +void test_streaming_compatible(void) __arm_streaming_compatible{ + svbfloat16_t svbfloat16_t_val; + svbfloat16x2_t svbfloat16x2_t_val; + svbfloat16x4_t svbfloat16x4_t_val; + + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svclamp_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmax_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmaxnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svmin_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x4_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_bf16_x2(svbfloat16x2_t_val, svbfloat16x2_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_bf16_x4(svbfloat16x4_t_val, svbfloat16x4_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_bf16_x2(svbfloat16x2_t_val, svbfloat16_t_val); + // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + svminnm_single_bf16_x4(svbfloat16x4_t_val, svbfloat16_t_val); +} diff --git a/clang/test/Sema/aarch64-streaming-sme-or-nonstreaming-sve-builtins.c b/clang/test/Sema/aarch64-streaming-sme-or-nonstreaming-sve-builtins.c deleted file mode 100644 index b873169f..0000000 --- a/clang/test/Sema/aarch64-streaming-sme-or-nonstreaming-sve-builtins.c +++ /dev/null @@ -1,70 +0,0 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py -// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify %s -// expected-no-diagnostics - -// REQUIRES: aarch64-registered-target - -#include <arm_sve.h> - -__attribute__((target("+sve2p1"))) -svfloat32_t good1(svfloat32_t a, svfloat32_t b, svfloat32_t c) { - return svclamp(a, b, c); -} - -__attribute__((target("+sme2"))) -svfloat32_t good2(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming { - return svclamp(a, b, c); -} - -__attribute__((target("+sve2p1,+sme2"))) -svfloat32_t good3(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible { - return svclamp(a, b, c); -} - -__attribute__((target("+sve2p1,+sme2"))) -svfloat32_t good4(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming { - return svclamp(a, b, c); -} - -__attribute__((target("+sve2p1"))) -svfloat32_t good5(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible { - return svclamp(a, b, c); -} - -// Even though svclamp is not available in streaming mode without +sme2, -// the behaviour should be the same as above, irrespective of whether +sme -// is passed or not. -__attribute__((target("+sve2p1,+sme"))) -svfloat32_t good6(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible { - return svclamp(a, b, c); -} - -// Test that the +sve-b16b16 is not considered an SVE flag (it applies to both) -__attribute__((target("+sme2,+sve2,+sve-b16b16"))) -svbfloat16_t good7(svbfloat16_t a, svbfloat16_t b, svbfloat16_t c) __arm_streaming { - return svclamp_bf16(a, b, c); -} - -// SVE features flags can enable streaming builtins. -__attribute__((target("+sve2p1,+sme"))) -svfloat32_t good8(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming { - return svclamp(a, b, c) + svclamp(a, b, c); -} - -// SME features flags can enable non-streaming builtins. -__attribute__((target("+sve,+sme2"))) -svfloat32_t good9(svfloat32_t a, svfloat32_t b, svfloat32_t c) { - return svclamp(a, b, c) + svclamp(a, b, c); -} - -// SME features flags can enable streaming-compatible builtins. -__attribute__((target("+sve,+sme2"))) -svfloat32_t good10(svfloat32_t a, svfloat32_t b, svfloat32_t c) __arm_streaming_compatible { - return svclamp(a, b, c) + svclamp(a, b, c); -} - -// We don't want a warning about undefined behaviour if none of the feature requirements of the builtin are satisfied. -// (this results in a target-guard error emitted by Clang CodeGen) -svfloat32_t bad5(svfloat32_t a, svfloat32_t b, svfloat32_t c) { - return svclamp(a, b, c); -} diff --git a/clang/test/Sema/warn-lifetime-safety.cpp b/clang/test/Sema/warn-lifetime-safety.cpp index f6bec6e..4f234f0 100644 --- a/clang/test/Sema/warn-lifetime-safety.cpp +++ b/clang/test/Sema/warn-lifetime-safety.cpp @@ -126,11 +126,15 @@ void definite_single_pointer_multiple_loans_gsl(bool cond) { v.use(); // expected-note 2 {{later used here}} } - -//===----------------------------------------------------------------------===// -// Potential (Maybe) Use-After-Free (-W...strict) -// These are cases where the pointer *may* become dangling, depending on the path taken. -//===----------------------------------------------------------------------===// +void definite_if_branch(bool cond) { + MyObj safe; + MyObj* p = &safe; + if (cond) { + MyObj temp; + p = &temp; // expected-warning {{object whose reference is captured does not live long enough}} + } // expected-note {{destroyed here}} + (void)*p; // expected-note {{later used here}} +} void potential_if_branch(bool cond) { MyObj safe; @@ -139,15 +143,18 @@ void potential_if_branch(bool cond) { MyObj temp; p = &temp; // expected-warning {{object whose reference is captured may not live long enough}} } // expected-note {{destroyed here}} - (void)*p; // expected-note {{later used here}} + if (!cond) + (void)*p; // expected-note {{later used here}} + else + p = &safe; } -void potential_if_branch_gsl(bool cond) { +void definite_if_branch_gsl(bool cond) { MyObj safe; View v = safe; if (cond) { MyObj temp; - v = temp; // expected-warning {{object whose reference is captured may not live long enough}} + v = temp; // expected-warning {{object whose reference is captured does not live long enough}} } // expected-note {{destroyed here}} v.use(); // expected-note {{later used here}} } @@ -159,13 +166,14 @@ void definite_potential_together(bool cond) { { MyObj s; - p_definite = &s; // expected-warning {{does not live long enough}} - if (cond) { - p_maybe = &s; // expected-warning {{may not live long enough}} - } - } // expected-note 2 {{destroyed here}} - (void)*p_definite; // expected-note {{later used here}} - (void)*p_maybe; // expected-note {{later used here}} + if (cond) + p_definite = &s; // expected-warning {{does not live long enough}} + if (cond) + p_maybe = &s; // expected-warning {{may not live long enough}} + } // expected-note 2 {{destroyed here}} + (void)*p_definite; // expected-note {{later used here}} + if (!cond) + (void)*p_maybe; // expected-note {{later used here}} } void definite_overrides_potential(bool cond) { @@ -189,10 +197,19 @@ void definite_overrides_potential(bool cond) { (void)*q; } - -//===----------------------------------------------------------------------===// -// Control Flow Tests -//===----------------------------------------------------------------------===// +void potential_due_to_conditional_killing(bool cond) { + MyObj safe; + MyObj* q; + { + MyObj s; + q = &s; // expected-warning {{may not live long enough}} + } // expected-note {{destroyed here}} + if (cond) { + // 'q' is conditionally "rescued". 'p' is not. + q = &safe; + } + (void)*q; // expected-note {{later used here}} +} void potential_for_loop_use_after_loop_body(MyObj safe) { MyObj* p = &safe; @@ -215,34 +232,35 @@ void potential_for_loop_gsl() { void potential_for_loop_use_before_loop_body(MyObj safe) { MyObj* p = &safe; + // Prefer the earlier use for diagnsotics. for (int i = 0; i < 1; ++i) { (void)*p; // expected-note {{later used here}} MyObj s; - p = &s; // expected-warning {{may not live long enough}} + p = &s; // expected-warning {{does not live long enough}} } // expected-note {{destroyed here}} (void)*p; } -void potential_loop_with_break(bool cond) { +void definite_loop_with_break(bool cond) { MyObj safe; MyObj* p = &safe; for (int i = 0; i < 10; ++i) { if (cond) { MyObj temp; - p = &temp; // expected-warning {{may not live long enough}} + p = &temp; // expected-warning {{does not live long enough}} break; // expected-note {{destroyed here}} } } (void)*p; // expected-note {{later used here}} } -void potential_loop_with_break_gsl(bool cond) { +void definite_loop_with_break_gsl(bool cond) { MyObj safe; View v = safe; for (int i = 0; i < 10; ++i) { if (cond) { MyObj temp; - v = temp; // expected-warning {{object whose reference is captured may not live long enough}} + v = temp; // expected-warning {{object whose reference is captured does not live long enough}} break; // expected-note {{destroyed here}} } } @@ -250,37 +268,52 @@ void potential_loop_with_break_gsl(bool cond) { } void potential_multiple_expiry_of_same_loan(bool cond) { - // Choose the last expiry location for the loan. + // Choose the last expiry location for the loan (e.g., through scope-ends and break statements). MyObj safe; MyObj* p = &safe; for (int i = 0; i < 10; ++i) { MyObj unsafe; if (cond) { - p = &unsafe; // expected-warning {{may not live long enough}} - break; + p = &unsafe; // expected-warning {{does not live long enough}} + break; // expected-note {{destroyed here}} } - } // expected-note {{destroyed here}} + } (void)*p; // expected-note {{later used here}} p = &safe; for (int i = 0; i < 10; ++i) { MyObj unsafe; if (cond) { - p = &unsafe; // expected-warning {{may not live long enough}} + p = &unsafe; // expected-warning {{does not live long enough}} if (cond) - break; + break; // expected-note {{destroyed here}} } - } // expected-note {{destroyed here}} + } (void)*p; // expected-note {{later used here}} p = &safe; for (int i = 0; i < 10; ++i) { if (cond) { MyObj unsafe2; - p = &unsafe2; // expected-warning {{may not live long enough}} + p = &unsafe2; // expected-warning {{does not live long enough}} break; // expected-note {{destroyed here}} } } + + // TODO: This can be argued to be a "maybe" warning. This is because + // we only check for confidence of liveness and not the confidence of + // the loan contained in an origin. To deal with this, we can introduce + // a confidence in loan propagation analysis as well like liveness. + (void)*p; // expected-note {{later used here}} + + p = &safe; + for (int i = 0; i < 10; ++i) { + MyObj unsafe; + if (cond) + p = &unsafe; // expected-warning {{does not live long enough}} + if (cond) + break; // expected-note {{destroyed here}} + } (void)*p; // expected-note {{later used here}} } @@ -298,13 +331,14 @@ void potential_switch(int mode) { break; } } - (void)*p; // expected-note {{later used here}} + if (mode == 2) + (void)*p; // expected-note {{later used here}} } void definite_switch(int mode) { MyObj safe; MyObj* p = &safe; - // All cases are UaF --> Definite error. + // A use domintates all the loan expires --> all definite error. switch (mode) { case 1: { MyObj temp1; @@ -347,6 +381,21 @@ void definite_switch_gsl(int mode) { v.use(); // expected-note 3 {{later used here}} } +void loan_from_previous_iteration(MyObj safe, bool condition) { + MyObj* p = &safe; + MyObj* q = &safe; + + while (condition) { + MyObj x; + p = &x; // expected-warning {{may not live long enough}} + + if (condition) + q = p; + (void)*p; + (void)*q; // expected-note {{later used here}} + } // expected-note {{destroyed here}} +} + //===----------------------------------------------------------------------===// // No-Error Cases //===----------------------------------------------------------------------===// @@ -372,6 +421,19 @@ void no_error_if_dangle_then_rescue_gsl() { v.use(); // This is safe. } +void no_error_loan_from_current_iteration(bool cond) { + // See https://github.com/llvm/llvm-project/issues/156959. + MyObj b; + while (cond) { + MyObj a; + View p = b; + if (cond) { + p = a; + } + (void)p; + } +} + //===----------------------------------------------------------------------===// // Lifetimebound Attribute Tests @@ -415,9 +477,9 @@ void lifetimebound_multiple_args_potential(bool cond) { MyObj obj1; if (cond) { MyObj obj2; - v = Choose(true, - obj1, // expected-warning {{object whose reference is captured may not live long enough}} - obj2); // expected-warning {{object whose reference is captured may not live long enough}} + v = Choose(true, + obj1, // expected-warning {{object whose reference is captured does not live long enough}} + obj2); // expected-warning {{object whose reference is captured does not live long enough}} } // expected-note {{destroyed here}} } // expected-note {{destroyed here}} v.use(); // expected-note 2 {{later used here}} @@ -488,7 +550,7 @@ void lifetimebound_partial_safety(bool cond) { MyObj temp_obj; v = Choose(true, safe_obj, - temp_obj); // expected-warning {{object whose reference is captured may not live long enough}} + temp_obj); // expected-warning {{object whose reference is captured does not live long enough}} } // expected-note {{destroyed here}} v.use(); // expected-note {{later used here}} } diff --git a/clang/test/SemaCXX/GH161671.cpp b/clang/test/SemaCXX/GH161671.cpp new file mode 100644 index 0000000..de09e54 --- /dev/null +++ b/clang/test/SemaCXX/GH161671.cpp @@ -0,0 +1,339 @@ +// RUN: %clang_cc1 -std=c++20 -w %s +// RUN: %clang_cc1 -std=c++2c -w %s +// expected-no-diagnostics + +namespace std { +template <typename _Tp, _Tp __v> struct integral_constant { + static constexpr _Tp value = __v; + using value_type = _Tp; +}; +template <bool __v> using __bool_constant = integral_constant<bool, __v>; +template <typename> struct is_integral : integral_constant<bool, true> {}; +template <typename> struct is_signed : integral_constant<bool, false> {}; +template <typename _Tp, typename _Up = _Tp> _Up __declval(int); +template <typename _Tp> auto declval() -> decltype(__declval<_Tp>(0)); +template <typename> struct make_unsigned { + using type = int; +}; +template <typename _Tp> struct decay { + using type = _Tp; +}; +template <int, typename _Iftrue, typename> struct conditional { + using type = _Iftrue; +}; +} // namespace std +namespace meta { +template <template <typename...> class> struct quote; +template <template <typename> class C, typename... Ts> +concept valid = requires { typename C<Ts...>; }; +template <typename T> +concept trait = requires { typename T; }; +template <typename T> +concept invocable = requires { typename quote<T::template invoke>; }; +template <typename T> +concept integral = requires { T::value; }; +template <trait T> using _t = T::type; +template <integral T> constexpr T::value_type _v = T::value; +template <bool B> using bool_ = std::integral_constant<bool, B>; +template <invocable Fn, typename... Args> +using invoke = Fn::template invoke<Args...>; +template <typename> struct id; +namespace detail { +template <template <typename> class, typename...> struct defer_; +template <template <typename> class C, typename... Ts> + requires valid<C, Ts...> +struct defer_<C, Ts...> { + using type = C<Ts...>; +}; +} // namespace detail +template <template <typename> class C, typename... Ts> +struct defer : detail::defer_<C, Ts...> {}; +template <template <typename...> class C> struct quote { + template <typename... Ts> using invoke = _t<defer<C, Ts...>>; +}; +namespace detail { +template <int> struct _cond { + template <typename Then, typename> using invoke = Then; +}; +template <> struct _cond<false>; +} // namespace detail +template <bool If, typename Then, typename Else> +using conditional_t = detail::_cond<If>::template invoke<Then, Else>; +namespace detail { +template <typename...> struct _if_; +template <typename If, typename Then, typename Else> +struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else> {}; +} // namespace detail +template <bool If, typename... Args> +using if_c = _t<detail::_if_<bool_<If>, Args...>>; +} // namespace meta +template <bool> void requires_(); +template <typename A, typename B> +concept same_as = __is_same(B, A); +namespace ranges { +template <typename> struct view_closure; +template <typename T> using decay_t = meta::_t<std::decay<T>>; +enum cardinality { unknown }; +template <cardinality> struct basic_view {}; +} // namespace ranges +namespace std { +template <typename> struct vector {}; +} // namespace std +namespace ranges { +struct { + template <typename F, typename... Args> + auto operator()(F f, Args... args) -> decltype(f(args...)); +} invoke; +template <typename Fun, typename... Args> +using invoke_result_t = + decltype(invoke(std::declval<Fun>(), std::declval<Args>()...)); +namespace detail { +struct with_difference_type_; +template <typename T> using iter_value_t_ = T ::value_type; +} // namespace detail +template <typename R> using iter_value_t = detail::iter_value_t_<R>; +namespace detail { +template <typename I> +using iter_size_t = + meta::_t<meta::conditional_t<std::is_integral<I>::value, + std::make_unsigned<I>, meta::id<I>>>; +template <typename D> +concept signed_integer_like_impl_concept_ = + std::integral_constant<bool, -D()>::value; +template <typename D> +concept signed_integer_like_ = signed_integer_like_impl_concept_<D>; +} // namespace detail +template <typename S, typename I> +concept sized_sentinel_for_requires_ = + requires(S s, I i) { requires_<same_as<I, decltype(i - s)>>; }; +template <typename S, typename I> +concept sized_sentinel_for = sized_sentinel_for_requires_<S, I>; +struct range_access { + template <typename Rng> + static auto begin_cursor(Rng rng) -> decltype(rng.begin_cursor()); + template <typename Cur, typename O> + static auto distance_to(Cur pos, O other) -> decltype(pos.distance_to(other)); +}; +namespace detail { +template <typename S, typename C> +concept sized_sentinel_for_cursor_requires_ = requires(S s, C c) { + requires_<signed_integer_like_<decltype(range_access::distance_to(c, s))>>; +}; +template <typename S, typename C> +concept sized_sentinel_for_cursor = sized_sentinel_for_cursor_requires_<S, C>; +struct iterator_associated_types_base_ { + typedef range_access value_type; +}; +template <typename> +using iterator_associated_types_base = iterator_associated_types_base_; +} // namespace detail +template <typename> +struct basic_iterator : detail::iterator_associated_types_base<int> {}; +template <typename Cur2, typename Cur> + requires detail::sized_sentinel_for_cursor<Cur2, Cur> +void operator-(basic_iterator<Cur2>, basic_iterator<Cur>); +namespace _begin_ { +template <typename T> +concept has_member_begin_requires_ = requires(T t) { t; }; +template <typename T> +concept has_member_begin = has_member_begin_requires_<T>; +struct _member_result_ { + template <typename R> + using invoke = decltype(static_cast<R (*)()>(nullptr)().begin()); +}; +struct _non_member_result_; +struct fn { + template <typename R> + using _result_t = + meta::invoke<meta::conditional_t<has_member_begin<R>, _member_result_, + _non_member_result_>, + R>; + template <typename R> _result_t<R> operator()(R); +}; +} // namespace _begin_ +_begin_::fn begin; +namespace _end_ { +template <typename> +concept has_member_end_requires_ = requires { begin; }; +template <typename T> +concept has_member_end = has_member_end_requires_<T>; +struct _member_result_ { + template <typename R> + using invoke = decltype(static_cast<R (*)()>(nullptr)().end()); +}; +struct _non_member_result_; +struct fn { + template <typename R> + using _result_t = + meta::invoke<meta::conditional_t<has_member_end<R>, _member_result_, + _non_member_result_>, + R>; + template <typename R> _result_t<R> operator()(R); +}; +} // namespace _end_ +_end_::fn end; +template <typename Rng> +using iterator_t = decltype(begin(static_cast<Rng (*)()>(nullptr)())); +template <typename Rng> +using sentinel_t = decltype(end(static_cast<Rng (*)()>(nullptr)())); +template <typename T> +concept has_member_size_requires_ = requires(T t) { t.size(); }; +template <typename T> +concept has_member_size = has_member_size_requires_<T>; +struct _other_result_; +struct _member_result_ { + template <typename> using invoke = decltype(0); + template <typename R> + using _result_t = meta::invoke< + meta::conditional_t<has_member_size<R>, _member_result_, _other_result_>, + R>; + template <typename R> _result_t<R> operator()(R r) { r.size(); } +} size; +template <typename Rng> using range_value_t = iter_value_t<iterator_t<Rng>>; +namespace detail { +template <cardinality Card> +std::integral_constant<cardinality, Card> test_cardinality(basic_view<Card> *); +} +template <typename Rng> +struct range_cardinality + : meta::conditional_t<__is_same(Rng, Rng), + decltype(detail::test_cardinality( + static_cast<Rng *>(nullptr))), + Rng> {}; +template <typename T> +concept sized_range_requires_ = requires(T t) { size(t); }; +template <typename T> +concept sized_range = sized_range_requires_<T>; +namespace detail { +template <int> struct dependent_ { + template <typename T> using invoke = T; +}; +} // namespace detail +template <typename Derived, cardinality Cardinality> +struct view_interface : basic_view<Cardinality> { + template <bool B> using D = meta::invoke<detail::dependent_<B>, Derived>; + Derived derived(); + template <bool True = true> + requires sized_sentinel_for<sentinel_t<D<True>>, iterator_t<D<True>>> + detail::iter_size_t<iterator_t<D<True>>> size() { + derived().end() - derived().begin(); + } +}; +struct { + template <typename Fun> view_closure<Fun> operator()(Fun); +} make_view_closure; +struct view_closure_base { + template <typename Rng, typename ViewFn> + friend auto operator|(Rng rng, ViewFn vw) { + return vw(rng); + } +}; +template <typename ViewFn> struct view_closure : view_closure_base, ViewFn {}; +namespace detail { +template <typename Derived> +using begin_cursor_t = + decay_t<decltype(range_access::begin_cursor(std::declval<Derived>()))>; +template <typename Derived> +using facade_iterator_t = basic_iterator<begin_cursor_t<Derived>>; +template <typename Derived> +using facade_sentinel_t = + meta::if_c<same_as<Derived, Derived>, facade_iterator_t<Derived>, Derived>; +} // namespace detail +template <typename Derived, cardinality Cardinality> +struct view_facade : view_interface<Derived, Cardinality> { + template <typename D = Derived> auto begin() -> detail::facade_iterator_t<D>; + template <typename D = Derived> auto end() -> detail::facade_sentinel_t<D>; +}; +template <typename Derived, cardinality Cardinality> +struct view_adaptor : view_facade<Derived, Cardinality> { + auto begin_cursor() -> decltype(0); +}; +namespace detail { +template <typename...> struct bind_back_fn_; +template <typename Fn, typename Arg> struct bind_back_fn_<Fn, Arg> { + template <typename... CallArgs> + invoke_result_t<Fn, CallArgs..., Arg> operator()(CallArgs...); +}; +template <typename Fn, typename... Args> +using bind_back_fn = bind_back_fn_<Fn, Args...>; +} // namespace detail +struct { + template <typename Fn, typename Arg1> + detail::bind_back_fn<Fn, Arg1> operator()(Fn, Arg1); +} bind_back; +namespace detail { +struct to_container { + template <typename> struct fn; + template <typename, typename> struct closure; +}; +template <typename, typename, typename R> +concept to_container_reserve = sized_range<R>; +template <typename MetaFn, typename Rng> +using container_t = meta::invoke<MetaFn, Rng>; +struct to_container_closure_base { + template <typename Rng, typename MetaFn, typename Fn> + friend auto operator|(Rng rng, to_container::closure<MetaFn, Fn> fn) { + return fn(rng); + } +}; +template <typename, typename Fn> +struct to_container::closure : to_container_closure_base, Fn {}; +template <typename MetaFn> struct to_container::fn { + template <typename Rng> void impl(Rng, std::__bool_constant<false>); + template <typename Rng> void impl(Rng rng, std::__bool_constant<true>) { + size(rng); + } + template <typename Rng> container_t<MetaFn, Rng> operator()(Rng rng) { + using cont_t = container_t<MetaFn, Rng>; + using iter_t = Rng; + using use_reserve_t = + meta::bool_<to_container_reserve<cont_t, iter_t, Rng>>; + impl(rng, use_reserve_t{}); + } +}; +template <typename MetaFn, typename Fn> +using to_container_closure = to_container::closure<MetaFn, Fn>; +template <typename MetaFn> +using to_container_fn = to_container_closure<MetaFn, to_container::fn<MetaFn>>; +template <template <typename> class ContT> struct from_range { + template <typename Rng> + static auto from_rng_(long) + -> meta::invoke<meta::quote<ContT>, range_value_t<Rng>>; + template <typename Rng> using invoke = decltype(from_rng_<Rng>(0)); +}; +} // namespace detail +detail::to_container_fn<detail::from_range<std::vector>> to_vector; +template <typename Rng> +struct remove_if_view + : view_adaptor<remove_if_view<Rng>, range_cardinality<Rng>::value> {}; +struct filter_base_fn { + template <typename Rng, typename Pred> + remove_if_view<Rng> operator()(Rng, Pred); + template <typename Pred> auto operator()(Pred pred) { + return make_view_closure(bind_back(filter_base_fn{}, pred)); + } +} filter; +namespace detail { +struct promote_as_signed_; +template <typename I> +using iota_difference_t = + meta::conditional_t<std::is_integral<I>::value, promote_as_signed_, + with_difference_type_>; +} // namespace detail +template <typename, typename> +struct iota_view : view_facade<iota_view<int, int>, unknown> { + struct cursor { + auto distance_to(cursor) -> detail::iota_difference_t<int>; + }; + cursor begin_cursor(); +}; +struct { + template <typename From, typename To> + requires(std::is_signed<From>::value == std::is_signed<To>::value) + iota_view<From, To> operator()(From, To); +} iota; +} // namespace ranges +void foo() { + ranges::iota(0, 1) | ranges::to_vector = + ranges::iota(0, 1) | ranges::filter([] {}) | ranges::to_vector; +} diff --git a/clang/test/SemaCXX/warn-unsafe-buffer-usage-unique-ptr.cpp b/clang/test/SemaCXX/warn-unsafe-buffer-usage-unique-ptr.cpp new file mode 100644 index 0000000..789d8a2 --- /dev/null +++ b/clang/test/SemaCXX/warn-unsafe-buffer-usage-unique-ptr.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -Wno-unused-value -Wunsafe-buffer-usage -fsafe-buffer-usage-suggestions -std=c++20 -verify=expected %s + +namespace std { +inline namespace __1 { +template <class T> class unique_ptr { +public: + T &operator[](long long i) const; +}; +} // namespace __1 +} // namespace std + +int get_index() { + return 4; +} + +void basic_unique_ptr() { + std::unique_ptr<int[]> p1; + int i = 2; + const int j = 3; + int k = 0; + + p1[0]; // This is allowed + + p1[k]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[1]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[1L]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[1LL]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[3 * 5]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[i]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[j]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[i + 5]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + + p1[get_index()]; // expected-warning{{direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking}} + +} + diff --git a/clang/test/Tooling/clang-linker-wrapper-spirv-elf.cpp b/clang/test/Tooling/clang-linker-wrapper-spirv-elf.cpp index 85208fc..8a7d36d 100644 --- a/clang/test/Tooling/clang-linker-wrapper-spirv-elf.cpp +++ b/clang/test/Tooling/clang-linker-wrapper-spirv-elf.cpp @@ -6,7 +6,7 @@ // RUN: cd %t_tmp // RUN: %clangxx -fopenmp -fopenmp-targets=spirv64-intel -nogpulib -c -o %t_clang-linker-wrapper-spirv-elf.o %s // RUN: not clang-linker-wrapper -o a.out %t_clang-linker-wrapper-spirv-elf.o --save-temps --linker-path=ld -// RUN: clang-offload-packager --image=triple=spirv64-intel,kind=openmp,file=%t.elf %t_tmp/a.out.openmp.image.wrapper.o +// RUN: llvm-offload-binary --image=triple=spirv64-intel,kind=openmp,file=%t.elf %t_tmp/a.out.openmp.image.wrapper.o // RUN: llvm-readelf -h %t.elf | FileCheck -check-prefix=CHECK-MACHINE %s // RUN: llvm-readelf -t %t.elf | FileCheck -check-prefix=CHECK-SECTION %s // RUN: llvm-readelf -n %t.elf | FileCheck -check-prefix=CHECK-NOTES %s diff --git a/clang/test/lit.cfg.py b/clang/test/lit.cfg.py index e6c79d7..29088ef 100644 --- a/clang/test/lit.cfg.py +++ b/clang/test/lit.cfg.py @@ -92,7 +92,7 @@ tools = [ "clang-diff", "clang-format", "clang-repl", - "clang-offload-packager", + "llvm-offload-binary", "clang-tblgen", "clang-scan-deps", "clang-installapi", |