diff options
Diffstat (limited to 'clang')
230 files changed, 73947 insertions, 2516 deletions
diff --git a/clang/docs/AllocToken.rst b/clang/docs/AllocToken.rst new file mode 100644 index 0000000..bda8466 --- /dev/null +++ b/clang/docs/AllocToken.rst @@ -0,0 +1,207 @@ +================= +Allocation Tokens +================= + +.. contents:: + :local: + +Introduction +============ + +Clang provides support for allocation tokens to enable allocator-level heap +organization strategies. Clang assigns mode-dependent token IDs to allocation +calls; the runtime behavior depends entirely on the implementation of a +compatible memory allocator. + +Possible allocator strategies include: + +* **Security Hardening**: Placing allocations into separate, isolated heap + partitions. For example, separating pointer-containing types from raw data + can mitigate exploits that rely on overflowing a primitive buffer to corrupt + object metadata. + +* **Memory Layout Optimization**: Grouping related allocations to improve data + locality and cache utilization. + +* **Custom Allocation Policies**: Applying different management strategies to + different partitions. + +Token Assignment Mode +===================== + +The default mode to calculate tokens is: + +* ``typehashpointersplit``: This mode assigns a token ID based on the hash of + the allocated type's name, where the top half ID-space is reserved for types + that contain pointers and the bottom half for types that do not contain + pointers. + +Other token ID assignment modes are supported, but they may be subject to +change or removal. These may (experimentally) be selected with ``-mllvm +-alloc-token-mode=<mode>``: + +* ``typehash``: This mode assigns a token ID based on the hash of the allocated + type's name. + +* ``random``: This mode assigns a statically-determined random token ID to each + allocation site. + +* ``increment``: This mode assigns a simple, incrementally increasing token ID + to each allocation site. + +Allocation Token Instrumentation +================================ + +To enable instrumentation of allocation functions, code can be compiled with +the ``-fsanitize=alloc-token`` flag: + +.. code-block:: console + + % clang++ -fsanitize=alloc-token example.cc + +The instrumentation transforms allocation calls to include a token ID. For +example: + +.. code-block:: c + + // Original: + ptr = malloc(size); + + // Instrumented: + ptr = __alloc_token_malloc(size, <token id>); + +The following command-line options affect generated token IDs: + +* ``-falloc-token-max=<N>`` + Configures the maximum number of tokens. No max by default (tokens bounded + by ``SIZE_MAX``). + + .. code-block:: console + + % clang++ -fsanitize=alloc-token -falloc-token-max=512 example.cc + +Runtime Interface +----------------- + +A compatible runtime must be provided that implements the token-enabled +allocation functions. The instrumentation generates calls to functions that +take a final ``size_t token_id`` argument. + +.. code-block:: c + + // C standard library functions + void *__alloc_token_malloc(size_t size, size_t token_id); + void *__alloc_token_calloc(size_t count, size_t size, size_t token_id); + void *__alloc_token_realloc(void *ptr, size_t size, size_t token_id); + // ... + + // C++ operators (mangled names) + // operator new(size_t, size_t) + void *__alloc_token__Znwm(size_t size, size_t token_id); + // operator new[](size_t, size_t) + void *__alloc_token__Znam(size_t size, size_t token_id); + // ... other variants like nothrow, etc., are also instrumented. + +Fast ABI +-------- + +An alternative ABI can be enabled with ``-fsanitize-alloc-token-fast-abi``, +which encodes the token ID hint in the allocation function name. + +.. code-block:: c + + void *__alloc_token_0_malloc(size_t size); + void *__alloc_token_1_malloc(size_t size); + void *__alloc_token_2_malloc(size_t size); + ... + void *__alloc_token_0_Znwm(size_t size); + void *__alloc_token_1_Znwm(size_t size); + void *__alloc_token_2_Znwm(size_t size); + ... + +This ABI provides a more efficient alternative where +``-falloc-token-max`` is small. + +Instrumenting Non-Standard Allocation Functions +----------------------------------------------- + +By default, AllocToken only instruments standard library allocation functions. +This simplifies adoption, as a compatible allocator only needs to provide +token-enabled variants for a well-defined set of standard functions. + +To extend instrumentation to custom allocation functions, enable broader +coverage with ``-fsanitize-alloc-token-extended``. Such functions require being +marked with the `malloc +<https://clang.llvm.org/docs/AttributeReference.html#malloc>`_ or `alloc_size +<https://clang.llvm.org/docs/AttributeReference.html#alloc-size>`_ attributes +(or a combination). + +For example: + +.. code-block:: c + + void *custom_malloc(size_t size) __attribute__((malloc)); + void *my_malloc(size_t size) __attribute__((alloc_size(1))); + + // Original: + ptr1 = custom_malloc(size); + ptr2 = my_malloc(size); + + // Instrumented: + ptr1 = __alloc_token_custom_malloc(size, token_id); + ptr2 = __alloc_token_my_malloc(size, token_id); + +Disabling Instrumentation +------------------------- + +To exclude specific functions from instrumentation, you can use the +``no_sanitize("alloc-token")`` attribute: + +.. code-block:: c + + __attribute__((no_sanitize("alloc-token"))) + void* custom_allocator(size_t size) { + return malloc(size); // Uses original malloc + } + +Note: Independent of any given allocator support, the instrumentation aims to +remain performance neutral. As such, ``no_sanitize("alloc-token")`` +functions may be inlined into instrumented functions and vice-versa. If +correctness is affected, such functions should explicitly be marked +``noinline``. + +The ``__attribute__((disable_sanitizer_instrumentation))`` is also supported to +disable this and other sanitizer instrumentations. + +Suppressions File (Ignorelist) +------------------------------ + +AllocToken respects the ``src`` and ``fun`` entity types in the +:doc:`SanitizerSpecialCaseList`, which can be used to omit specified source +files or functions from instrumentation. + +.. code-block:: bash + + [alloc-token] + # Exclude specific source files + src:third_party/allocator.c + # Exclude function name patterns + fun:*custom_malloc* + fun:LowLevel::* + +.. code-block:: console + + % clang++ -fsanitize=alloc-token -fsanitize-ignorelist=my_ignorelist.txt example.cc + +Conditional Compilation with ``__SANITIZE_ALLOC_TOKEN__`` +----------------------------------------------------------- + +In some cases, one may need to execute different code depending on whether +AllocToken instrumentation is enabled. The ``__SANITIZE_ALLOC_TOKEN__`` macro +can be used for this purpose. + +.. code-block:: c + + #ifdef __SANITIZE_ALLOC_TOKEN__ + // Code specific to -fsanitize=alloc-token builds + #endif diff --git a/clang/docs/DebuggingCoroutines.rst b/clang/docs/DebuggingCoroutines.rst index 9eaf8d4..c62e2ea 100644 --- a/clang/docs/DebuggingCoroutines.rst +++ b/clang/docs/DebuggingCoroutines.rst @@ -179,8 +179,8 @@ generator and its internal state. To do so, we can simply look into the ``gen.hdl`` variable. LLDB comes with a pretty printer for ``std::coroutine_handle`` which will show us the internal -state of the coroutine. For GDB, you will have to use the ``show-coro-frame`` -command provided by the :ref:`gdb-script`. +state of the coroutine. For GDB, the pretty printer is provided by a script, +see :ref:`gdb-script` for setup instructions. .. image:: ./coro-generator-suspended.png @@ -206,23 +206,16 @@ Tracking the exact suspension point Among the compiler-generated members, the ``__coro_index`` is particularly important. This member identifies the suspension point at which the coroutine -is currently suspended. +is currently suspended. However, it is non-trivial to map this number back to +a source code location. -However, it is non-trivial to map this number back to a source code location. -The compiler emits debug info labels for the suspension points. This allows us -to map the suspension point index back to a source code location. In gdb, we -can use the ``info line`` command to get the source code location of the -suspension point. +For GDB, the provided :ref:`gdb-script` already takes care of this and provides +the exact line number of the suspension point as part of the coroutine handle's +summary string. Unfortunately, LLDB's pretty-printer does not support this, yet. +Furthermore, those labels are only emitted starting with clang 21.0. -:: - - (gdb) info line -function coro_task -label __coro_resume_2 - Line 45 of "llvm-example.cpp" starts at address 0x1b1b <_ZL9coro_taski.resume+555> and ends at 0x1b46 <_ZL9coro_taski.resume+598>. - Line 45 of "llvm-example.cpp" starts at address 0x201b <_ZL9coro_taski.destroy+555> and ends at 0x2046 <_ZL9coro_taski.destroy+598>. - Line 45 of "llvm-example.cpp" starts at address 0x253b <_ZL9coro_taski.cleanup+555> and ends at 0x2566 <_ZL9coro_taski.cleanup+598>. - -LLDB does not support looking up labels. Furthermore, those labels are only emitted -starting with clang 21.0. +When debugging with LLDB or when using older clang versions, we will have to use +a different approach. For simple cases, you might still be able to guess the suspension point correctly. Alternatively, you might also want to modify your coroutine library to store @@ -655,33 +648,17 @@ There are two possible approaches to do so: We can lookup their types and thereby get the types of promise and coroutine frame. -In gdb, one can use the following approach to devirtualize a coroutine type, -assuming we have a ``std::coroutine_handle`` is at address 0x418eb0: - -:: +In general, the second approach is preferred, as it is more portable. - (gdb) # Get the address of coroutine frame - (gdb) print/x *0x418eb0 - $1 = 0x4019e0 - (gdb) # Get the linkage name for the coroutine - (gdb) x 0x4019e0 - 0x4019e0 <_ZL9coro_taski>: 0xe5894855 - (gdb) # Turn off the demangler temporarily to avoid the debugger misunderstanding the name. - (gdb) set demangle-style none - (gdb) # The coroutine frame type is 'linkage_name.coro_frame_ty' - (gdb) print ('_ZL9coro_taski.coro_frame_ty')*(0x418eb0) - $2 = {__resume_fn = 0x4019e0 <coro_task(int)>, __destroy_fn = 0x402000 <coro_task(int)>, __promise = {...}, ...} - -In practice, one would use the ``show-coro-frame`` command provided by the -:ref:`gdb-script`. +To do so, we look up the types in the destroy function and not the resume function +because the resume function pointer will be set to a ``nullptr`` as soon as a +coroutine reaches its final suspension point. If we used the resume function, +devirtualization would hence fail for all coroutines that have reached their final +suspension point. LLDB comes with devirtualization support out of the box, as part of the -pretty-printer for ``std::coroutine_handle``. Internally, this pretty-printer -uses the second approach. We look up the types in the destroy function and not -the resume function because the resume function pointer will be set to a -``nullptr`` as soon as a coroutine reaches its final suspension point. If we used -the resume function, devirtualization would hence fail for all coroutines that -have reached their final suspension point. +pretty-printer for ``std::coroutine_handle``. For GDB, a similar pretty-printer +is provided by the :ref:`gdb-script`. Interpreting the coroutine frame in optimized builds ---------------------------------------------------- @@ -756,6 +733,26 @@ should not be thought of as directly representing the variables in the C++ source. +Mapping suspension point indices to source code locations +--------------------------------------------------------- + +To aid in mapping a ``__coro_index`` back to a source code location, clang 21.0 +and newer emit special, compiler-generated labels for the suspension points. + +In gdb, we can use the ``info line`` command to get the source code location of +the suspension point. + +:: + + (gdb) info line -function coro_task -label __coro_resume_2 + Line 45 of "llvm-example.cpp" starts at address 0x1b1b <_ZL9coro_taski.resume+555> and ends at 0x1b46 <_ZL9coro_taski.resume+598>. + Line 45 of "llvm-example.cpp" starts at address 0x201b <_ZL9coro_taski.destroy+555> and ends at 0x2046 <_ZL9coro_taski.destroy+598>. + Line 45 of "llvm-example.cpp" starts at address 0x253b <_ZL9coro_taski.cleanup+555> and ends at 0x2566 <_ZL9coro_taski.cleanup+598>. + +LLDB does not support looking up labels, yet. For this reason, LLDB's pretty-printer +does not show the exact line number of the suspension point. + + Resources ========= @@ -1017,156 +1014,270 @@ Note that this script requires LLDB 21.0 or newer. GDB Debugger Script ------------------- -For GDB, the following script provides a couple of useful commands: +The following script provides: -* ``async-bt`` to print the stack trace of a coroutine -* ``show-coro-frame`` to print the coroutine frame, similar to - LLDB's builtin pretty-printer for coroutine frames +* a pretty-printer for coroutine handles +* a frame filter to add coroutine frames to the built-in ``bt`` command +* the ``get_coro_frame`` and ``get_coro_promise`` functions to be used in + expressions, e.g. ``p get_coro_promise(fib.coro_hdl)->current_state`` + +It can be loaded into GDB using ``source gdb_coro_debugging.py``. +To load this by default, add this command to your ``~/.gdbinit`` file. .. code-block:: python - # debugging-helper.py + # gdb_coro_debugging.py import gdb from gdb.FrameDecorator import FrameDecorator - class SymValueWrapper(): - def __init__(self, symbol, value): - self.sym = symbol - self.val = value + import typing + import re - def __str__(self): - return str(self.sym) + " = " + str(self.val) + def _load_pointer_at(addr: int): + return gdb.Value(addr).reinterpret_cast(gdb.lookup_type('void').pointer().pointer()).dereference() - def get_long_pointer_size(): - return gdb.lookup_type('long').pointer().sizeof + """ + Devirtualized coroutine frame. - def cast_addr2long_pointer(addr): - return gdb.Value(addr).cast(gdb.lookup_type('long').pointer()) + Devirtualizes the promise and frame pointer types by inspecting + the destroy function. - def dereference(addr): - return long(cast_addr2long_pointer(addr).dereference()) + Implements `to_string` and `children` to be used by `gdb.printing.PrettyPrinter`. + Base class for `CoroutineHandlePrinter`. + """ + class DevirtualizedCoroFrame: + def __init__(self, frame_ptr_raw: int, val: gdb.Value | None = None): + self.val = val + self.frame_ptr_raw = frame_ptr_raw - class CoroutineFrame(object): - def __init__(self, task_addr): - self.frame_addr = task_addr - self.resume_addr = task_addr - self.destroy_addr = task_addr + get_long_pointer_size() - self.promise_addr = task_addr + get_long_pointer_size() * 2 - # In the example, the continuation is the first field member of the promise_type. - # So they have the same addresses. - # If we want to generalize the scripts to other coroutine types, we need to be sure - # the continuation field is the first member of promise_type. - self.continuation_addr = self.promise_addr + # Get the resume and destroy pointers. + if frame_ptr_raw == 0: + self.resume_ptr = None + self.destroy_ptr = None + self.promise_ptr = None + self.frame_ptr = gdb.Value(frame_ptr_raw).reinterpret_cast(gdb.lookup_type("void").pointer()) + return - def next_task_addr(self): - return dereference(self.continuation_addr) + # Get the resume and destroy pointers. + self.resume_ptr = _load_pointer_at(frame_ptr_raw) + self.destroy_ptr = _load_pointer_at(frame_ptr_raw + 8) + + # Devirtualize the promise and frame pointer types. + frame_type = gdb.lookup_type("void") + promise_type = gdb.lookup_type("void") + self.destroy_func = gdb.block_for_pc(int(self.destroy_ptr)) + if self.destroy_func is not None: + frame_var = gdb.lookup_symbol("__coro_frame", self.destroy_func, gdb.SYMBOL_VAR_DOMAIN)[0] + if frame_var is not None: + frame_type = frame_var.type + promise_var = gdb.lookup_symbol("__promise", self.destroy_func, gdb.SYMBOL_VAR_DOMAIN)[0] + if promise_var is not None: + promise_type = promise_var.type.strip_typedefs() + + # If the type has a template argument, prefer it over the devirtualized type. + if self.val is not None: + promise_type_template_arg = self.val.type.template_argument(0) + if promise_type_template_arg is not None and promise_type_template_arg.code != gdb.TYPE_CODE_VOID: + promise_type = promise_type_template_arg + + self.promise_ptr = gdb.Value(frame_ptr_raw + 16).reinterpret_cast(promise_type.pointer()) + self.frame_ptr = gdb.Value(frame_ptr_raw).reinterpret_cast(frame_type.pointer()) + + # Try to get the suspension point index and look up the exact line entry. + self.suspension_point_index = int(self.frame_ptr.dereference()["__coro_index"]) if frame_type.code == gdb.TYPE_CODE_STRUCT else None + self.resume_func = gdb.block_for_pc(int(self.resume_ptr)) + self.resume_label = None + if self.resume_func is not None and self.suspension_point_index is not None: + label_name = f"__coro_resume_{self.suspension_point_index}" + self.resume_label = gdb.lookup_symbol(label_name, self.resume_func, gdb.SYMBOL_LABEL_DOMAIN)[0] + + def get_function_name(self): + if self.destroy_func is None: + return None + name = self.destroy_func.function.name + # Strip the "clone" suffix if it exists. + if "() [clone " in name: + name = name[:name.index("() [clone ")] + return name + + def to_string(self): + result = "coro(" + str(self.frame_ptr_raw) + ")" + if self.destroy_func is not None: + result += ": " + self.get_function_name() + if self.resume_label is not None: + result += ", line " + str(self.resume_label.line) + if self.suspension_point_index is not None: + result += ", suspension point " + str(self.suspension_point_index) + return result + + def children(self): + if self.resume_ptr is None: + return [ + ("coro_frame", self.frame_ptr), + ] + else: + return [ + ("resume", self.resume_ptr), + ("destroy", self.destroy_ptr), + ("promise", self.promise_ptr), + ("coro_frame", self.frame_ptr) + ] - class CoroutineFrameDecorator(FrameDecorator): - def __init__(self, coro_frame): - super(CoroutineFrameDecorator, self).__init__(None) - self.coro_frame = coro_frame - self.resume_func = dereference(self.coro_frame.resume_addr) - self.resume_func_block = gdb.block_for_pc(self.resume_func) - if self.resume_func_block is None: - raise Exception('Not stackless coroutine.') - self.line_info = gdb.find_pc_line(self.resume_func) - def address(self): - return self.resume_func + # Works for both libc++ and libstdc++. + libcxx_corohdl_regex = re.compile('^std::__[A-Za-z0-9]+::coroutine_handle<.+>$|^std::coroutine_handle<.+>(( )?&)?$') - def filename(self): - return self.line_info.symtab.filename + def _extract_coro_frame_ptr_from_handle(val: gdb.Value): + if libcxx_corohdl_regex.match(val.type.strip_typedefs().name) is None: + raise ValueError("Expected a std::coroutine_handle, got %s" % val.type.strip_typedefs().name) - def frame_args(self): - return [SymValueWrapper("frame_addr", cast_addr2long_pointer(self.coro_frame.frame_addr)), - SymValueWrapper("promise_addr", cast_addr2long_pointer(self.coro_frame.promise_addr)), - SymValueWrapper("continuation_addr", cast_addr2long_pointer(self.coro_frame.continuation_addr)) - ] + # We expect the coroutine handle to have a single field, which is the frame pointer. + # This heuristic works for both libc++ and libstdc++. + fields = val.type.fields() + if len(fields) != 1: + raise ValueError("Expected 1 field, got %d" % len(fields)) + return int(val[fields[0]]) - def function(self): - return self.resume_func_block.function.print_name - def line(self): - return self.line_info.line - - class StripDecorator(FrameDecorator): - def __init__(self, frame): - super(StripDecorator, self).__init__(frame) - self.frame = frame - f = frame.function() - self.function_name = f - - def __str__(self, shift = 2): - addr = "" if self.address() is None else '%#x' % self.address() + " in " - location = "" if self.filename() is None else " at " + self.filename() + ":" + str(self.line()) - return addr + self.function() + " " + str([str(args) for args in self.frame_args()]) + location - - class CoroutineFilter: - def create_coroutine_frames(self, task_addr): - frames = [] - while task_addr != 0: - coro_frame = CoroutineFrame(task_addr) - frames.append(CoroutineFrameDecorator(coro_frame)) - task_addr = coro_frame.next_task_addr() - return frames - - class AsyncStack(gdb.Command): + """ + Pretty printer for `std::coroutine_handle<T>` + + Works for both libc++ and libstdc++. + + It prints the coroutine handle as a struct with the following fields: + - resume: the resume function pointer + - destroy: the destroy function pointer + - promise: the promise pointer + - coro_frame: the coroutine frame pointer + + Most of the functionality is implemented in `DevirtualizedCoroFrame`. + """ + class CoroutineHandlePrinter(DevirtualizedCoroFrame): + def __init__(self, val : gdb.Value): + frame_ptr_raw = _extract_coro_frame_ptr_from_handle(val) + super(CoroutineHandlePrinter, self).__init__(frame_ptr_raw, val) + + + def build_pretty_printer(): + pp = gdb.printing.RegexpCollectionPrettyPrinter("coroutine") + pp.add_printer('std::coroutine_handle', libcxx_corohdl_regex, CoroutineHandlePrinter) + return pp + + gdb.printing.register_pretty_printer( + gdb.current_objfile(), + build_pretty_printer()) + + + """ + Get the coroutine frame pointer from a coroutine handle. + + Usage: + ``` + p *get_coro_frame(coroutine_hdl) + ``` + """ + class GetCoroFrame(gdb.Function): def __init__(self): - super(AsyncStack, self).__init__("async-bt", gdb.COMMAND_USER) + super(GetCoroFrame, self).__init__("get_coro_frame") - def invoke(self, arg, from_tty): - coroutine_filter = CoroutineFilter() - argv = gdb.string_to_argv(arg) - if len(argv) == 0: - try: - task = gdb.parse_and_eval('__coro_frame') - task = int(str(task.address), 16) - except Exception: - print ("Can't find __coro_frame in current context.\n" + - "Please use `async-bt` in stackless coroutine context.") - return - elif len(argv) != 1: - print("usage: async-bt <pointer to task>") - return - else: - task = int(argv[0], 16) + def invoke(self, coroutine_hdl_raw): + return CoroutineHandlePrinter(coroutine_hdl_raw).frame_ptr + + GetCoroFrame() - frames = coroutine_filter.create_coroutine_frames(task) - i = 0 - for f in frames: - print '#'+ str(i), str(StripDecorator(f)) - i += 1 - return - AsyncStack() + """ + Get the coroutine frame pointer from a coroutine handle. - class ShowCoroFrame(gdb.Command): + Usage: + ``` + p *get_coro_promise(coroutine_hdl) + ``` + """ + class GetCoroFrame(gdb.Function): def __init__(self): - super(ShowCoroFrame, self).__init__("show-coro-frame", gdb.COMMAND_USER) + super(GetCoroFrame, self).__init__("get_coro_promise") - def invoke(self, arg, from_tty): - argv = gdb.string_to_argv(arg) - if len(argv) != 1: - print("usage: show-coro-frame <address of coroutine frame>") - return + def invoke(self, coroutine_hdl_raw): + return CoroutineHandlePrinter(coroutine_hdl_raw).promise_ptr - addr = int(argv[0], 16) - block = gdb.block_for_pc(long(cast_addr2long_pointer(addr).dereference())) - if block is None: - print "block " + str(addr) + " is None." - return + GetCoroFrame() + + + """ + Decorator for coroutine frames. + + Used by `CoroutineFrameFilter` to add the coroutine frames to the built-in `bt` command. + """ + class CoroutineFrameDecorator(FrameDecorator): + def __init__(self, coro_frame: DevirtualizedCoroFrame, inferior_frame: gdb.Frame): + super(CoroutineFrameDecorator, self).__init__(inferior_frame) + self.coro_frame = coro_frame + + def function(self): + func_name = self.coro_frame.get_function_name() + if func_name is not None: + return "[async] " + func_name + return "[async] coroutine (coro_frame=" + str(self.coro_frame.frame_ptr_raw) + ")" + + def address(self): + return None + + def filename(self): + if self.coro_frame.destroy_func is not None: + return self.coro_frame.destroy_func.function.symtab.filename + return None + + def line(self): + if self.coro_frame.resume_label is not None: + return self.coro_frame.resume_label.line + return None + + def frame_args(self): + return [] + + def frame_locals(self): + return [] + + + def _get_continuation(promise: gdb.Value) -> DevirtualizedCoroFrame | None: + try: + # TODO: adjust this according for your coroutine framework + return DevirtualizedCoroFrame(_extract_coro_frame_ptr_from_handle(promise["continuation"])) + except Exception as e: + return None - # Disable demangling since gdb will treat names starting with `_Z`(The marker for Itanium ABI) specially. - gdb.execute("set demangle-style none") - coro_frame_type = gdb.lookup_type(block.function.linkage_name + ".coro_frame_ty") - coro_frame_ptr_type = coro_frame_type.pointer() - coro_frame = gdb.Value(addr).cast(coro_frame_ptr_type).dereference() + def _create_coroutine_frames(coro_frame: DevirtualizedCoroFrame, inferior_frame: gdb.Frame): + while coro_frame is not None: + yield CoroutineFrameDecorator(coro_frame, inferior_frame) + coro_frame = _get_continuation(coro_frame.promise_ptr) - gdb.execute("set demangle-style auto") - gdb.write(coro_frame.format_string(pretty_structs = True)) - ShowCoroFrame() + """ + Frame filter to add coroutine frames to the built-in `bt` command. + """ + class CppCoroutineFrameFilter(): + def __init__(self): + self.name = "CppCoroutineFrameFilter" + self.priority = 50 + self.enabled = True + # Register this frame filter with the global frame_filters dictionary. + gdb.frame_filters[self.name] = self + + def filter(self, frame_iter: typing.Iterable[gdb.FrameDecorator]): + for frame in frame_iter: + yield frame + inferior_frame = frame.inferior_frame() + try: + promise_ptr = inferior_frame.read_var("__promise") + except Exception: + continue + parent_coro = _get_continuation(promise_ptr) + if parent_coro is not None: + yield from _create_coroutine_frames(parent_coro, inferior_frame) + + CppCoroutineFrameFilter() Further Reading --------------- diff --git a/clang/docs/OpenMPSupport.rst b/clang/docs/OpenMPSupport.rst index 90c0186..cdb3b33 100644 --- a/clang/docs/OpenMPSupport.rst +++ b/clang/docs/OpenMPSupport.rst @@ -548,7 +548,7 @@ implementation. +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
| Increment between places for OMP_PLACES | :none:`unclaimed` | :none:`unclaimed` | |
+-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
-| OMP_AVAILABLE_DEVICES envirable | :none:`unclaimed` | :none:`unclaimed` | |
+| OMP_AVAILABLE_DEVICES envirable | :none:`unclaimed` | :none:`unclaimed` | (should wait for "Traits for default device envirable" being done) |
+-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
| Traits for default device envirable | :part:`in progress` | :none:`unclaimed` | ro-i |
+-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 5e9a71e..99aa545 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -257,10 +257,16 @@ Non-comprehensive list of changes in this release - Fixed a crash when the second argument to ``__builtin_assume_aligned`` was not constant (#GH161314) +- Introduce support for :doc:`allocation tokens <AllocToken>` to enable + allocator-level heap organization strategies. A feature to instrument all + allocation functions with a token ID can be enabled via the + ``-fsanitize=alloc-token`` flag. + New Compiler Flags ------------------ - New option ``-fno-sanitize-debug-trap-reasons`` added to disable emitting trap reasons into the debug info when compiling with trapping UBSan (e.g. ``-fsanitize-trap=undefined``). - New option ``-fsanitize-debug-trap-reasons=`` added to control emitting trap reasons into the debug info when compiling with trapping UBSan (e.g. ``-fsanitize-trap=undefined``). +- New options for enabling allocation token instrumentation: ``-fsanitize=alloc-token``, ``-falloc-token-max=``, ``-fsanitize-alloc-token-fast-abi``, ``-fsanitize-alloc-token-extended``. Lanai Support @@ -351,6 +357,11 @@ Improvements to Clang's diagnostics properly being rejected when used at compile-time. It was not implemented and caused assertion failures before (#GH158471). +- Closed a loophole in the diagnosis of function pointer conversions changing + extended function type information in C mode (#GH41465). Function conversions + that were previously incorrectly accepted in case of other irrelevant + conditions are now consistently diagnosed, identical to C++ mode. + Improvements to Clang's time-trace ---------------------------------- @@ -449,6 +460,7 @@ Bug Fixes to C++ Support - Fix a crash when attempting to deduce a deduction guide from a non deducible template template parameter. (#130604) - Fix for clang incorrectly rejecting the default construction of a union with nontrivial member when another member has an initializer. (#GH81774) +- Diagnose unresolved overload sets in non-dependent compound requirements. (#GH51246) (#GH97753) Bug Fixes to AST Handling ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst index a8bbf14..12c2ada 100644 --- a/clang/docs/UsersManual.rst +++ b/clang/docs/UsersManual.rst @@ -2155,13 +2155,11 @@ are listed below. .. option:: -f[no-]sanitize=check1,check2,... - Turn on runtime checks for various forms of undefined or suspicious - behavior. + Turn on runtime checks or mitigations for various forms of undefined or + suspicious behavior. These are disabled by default. - This option controls whether Clang adds runtime checks for various - forms of undefined or suspicious behavior, and is disabled by - default. If a check fails, a diagnostic message is produced at - runtime explaining the problem. The main checks are: + The following options enable runtime checks for various forms of undefined + or suspicious behavior: - .. _opt_fsanitize_address: @@ -2195,6 +2193,14 @@ are listed below. - ``-fsanitize=realtime``: :doc:`RealtimeSanitizer`, a real-time safety checker. + The following options enable runtime mitigations for various forms of + undefined or suspicious behavior: + + - ``-fsanitize=alloc-token``: Enables :doc:`allocation tokens <AllocToken>` + for allocator-level heap organization strategies, such as for security + hardening. It passes type-derived token IDs to a compatible memory + allocator. Requires linking against a token-aware allocator. + There are more fine-grained checks available: see the :ref:`list <ubsan-checks>` of specific kinds of undefined behavior that can be detected and the :ref:`list <cfi-schemes>` diff --git a/clang/docs/index.rst b/clang/docs/index.rst index e238518..272ae54 100644 --- a/clang/docs/index.rst +++ b/clang/docs/index.rst @@ -40,6 +40,7 @@ Using Clang as a Compiler SanitizerCoverage SanitizerStats SanitizerSpecialCaseList + AllocToken BoundsSafety BoundsSafetyAdoptionGuide BoundsSafetyImplPlans diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h index a3c67a6..a4a1bb9 100644 --- a/clang/include/clang/AST/DeclTemplate.h +++ b/clang/include/clang/AST/DeclTemplate.h @@ -3395,9 +3395,10 @@ inline UnsignedOrNone getExpandedPackSize(const NamedDecl *Param) { return std::nullopt; } -/// Internal helper used by Subst* nodes to retrieve the parameter list -/// for their AssociatedDecl. -TemplateParameterList *getReplacedTemplateParameterList(const Decl *D); +/// Internal helper used by Subst* nodes to retrieve a parameter from the +/// AssociatedDecl, and the template argument substituted into it, if any. +std::tuple<NamedDecl *, TemplateArgument> +getReplacedTemplateParameter(Decl *D, unsigned Index); /// If we have a 'templated' declaration for a template, adjust 'D' to /// refer to the actual template. diff --git a/clang/include/clang/AST/HLSLResource.h b/clang/include/clang/AST/HLSLResource.h index 7440050..1be1e42 100644 --- a/clang/include/clang/AST/HLSLResource.h +++ b/clang/include/clang/AST/HLSLResource.h @@ -74,6 +74,19 @@ struct ResourceBindingAttrs { assert(hasBinding() && !isExplicit() && !hasImplicitOrderID()); RegBinding->setImplicitBindingOrderID(Value); } + void setCounterImplicitOrderID(unsigned Value) const { + assert(hasBinding() && !hasCounterImplicitOrderID()); + RegBinding->setImplicitCounterBindingOrderID(Value); + } + + bool hasCounterImplicitOrderID() const { + return RegBinding && RegBinding->hasImplicitCounterBindingOrderID(); + } + + unsigned getCounterImplicitOrderID() const { + assert(hasCounterImplicitOrderID()); + return RegBinding->getImplicitCounterBindingOrderID(); + } }; } // namespace hlsl diff --git a/clang/include/clang/AST/OpenACCClause.h b/clang/include/clang/AST/OpenACCClause.h index 58ba8d91..79cffeb 100644 --- a/clang/include/clang/AST/OpenACCClause.h +++ b/clang/include/clang/AST/OpenACCClause.h @@ -1280,13 +1280,31 @@ public: // 'main' declaration used for initializaiton, which is fixed. struct OpenACCReductionRecipe { VarDecl *AllocaDecl; - // TODO: OpenACC: this should eventually have the operations here too. - OpenACCReductionRecipe(VarDecl *A) : AllocaDecl(A) {} + // A combiner recipe is represented by an operation expression. However, in + // order to generate these properly, we have to make up a LHS and a RHS + // expression for the purposes of generation. + struct CombinerRecipe { + VarDecl *LHS; + VarDecl *RHS; + Expr *Op; + }; + + // Contains a collection of the recipe elements we need for the combiner: + // -For Scalars, there will be 1 element, just the combiner for that scalar. + // -For a struct with a valid operator, this will be 1 element, just that + // call. + // -For a struct without the operator, this will be 1 element per field, which + // should be the combiner for that element. + // -For an array of any of the above, it will be the above for the element. + llvm::SmallVector<CombinerRecipe, 1> CombinerRecipes; + + OpenACCReductionRecipe(VarDecl *A, llvm::ArrayRef<CombinerRecipe> Combiners) + : AllocaDecl(A), CombinerRecipes(Combiners) {} bool isSet() const { return AllocaDecl; } static OpenACCReductionRecipe Empty() { - return OpenACCReductionRecipe(/*AllocaDecl=*/nullptr); + return OpenACCReductionRecipe(/*AllocaDecl=*/nullptr, {}); } }; diff --git a/clang/include/clang/AST/TypeBase.h b/clang/include/clang/AST/TypeBase.h index 6786b2f..625cc77 100644 --- a/clang/include/clang/AST/TypeBase.h +++ b/clang/include/clang/AST/TypeBase.h @@ -7082,10 +7082,6 @@ public: class SubstTemplateTypeParmPackType : public SubstPackType { friend class ASTContext; - /// A pointer to the set of template arguments that this - /// parameter pack is instantiated with. - const TemplateArgument *Arguments; - llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal; SubstTemplateTypeParmPackType(QualType Canon, Decl *AssociatedDecl, diff --git a/clang/include/clang/ASTMatchers/GtestMatchers.h b/clang/include/clang/ASTMatchers/GtestMatchers.h deleted file mode 100644 index e19d91a..0000000 --- a/clang/include/clang/ASTMatchers/GtestMatchers.h +++ /dev/null @@ -1,87 +0,0 @@ -//===- GtestMatchers.h - AST Matchers for GTest -----------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file implements matchers specific to structures in the Googletest -// (gtest) framework. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CLANG_ASTMATCHERS_GTESTMATCHERS_H -#define LLVM_CLANG_ASTMATCHERS_GTESTMATCHERS_H - -#include "clang/AST/Stmt.h" -#include "clang/ASTMatchers/ASTMatchers.h" -#include "llvm/ADT/StringRef.h" - -namespace clang { -namespace ast_matchers { - -/// Gtest's comparison operations. -enum class GtestCmp { - Eq, - Ne, - Ge, - Gt, - Le, - Lt, -}; - -/// This enum indicates whether the mock method in the matched ON_CALL or -/// EXPECT_CALL macro has arguments. For example, `None` can be used to match -/// `ON_CALL(mock, TwoParamMethod)` whereas `Some` can be used to match -/// `ON_CALL(mock, TwoParamMethod(m1, m2))`. -enum class MockArgs { - None, - Some, -}; - -/// Matcher for gtest's ASSERT comparison macros including ASSERT_EQ, ASSERT_NE, -/// ASSERT_GE, ASSERT_GT, ASSERT_LE and ASSERT_LT. -internal::BindableMatcher<Stmt> gtestAssert(GtestCmp Cmp, StatementMatcher Left, - StatementMatcher Right); - -/// Matcher for gtest's ASSERT_THAT macro. -internal::BindableMatcher<Stmt> gtestAssertThat(StatementMatcher Actual, - StatementMatcher Matcher); - -/// Matcher for gtest's EXPECT comparison macros including EXPECT_EQ, EXPECT_NE, -/// EXPECT_GE, EXPECT_GT, EXPECT_LE and EXPECT_LT. -internal::BindableMatcher<Stmt> gtestExpect(GtestCmp Cmp, StatementMatcher Left, - StatementMatcher Right); - -/// Matcher for gtest's EXPECT_THAT macro. -internal::BindableMatcher<Stmt> gtestExpectThat(StatementMatcher Actual, - StatementMatcher Matcher); - -/// Matcher for gtest's EXPECT_CALL macro. `MockObject` matches the mock -/// object and `MockMethodName` is the name of the method invoked on the mock -/// object. -internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockObject, - llvm::StringRef MockMethodName, - MockArgs Args); - -/// Matcher for gtest's EXPECT_CALL macro. `MockCall` matches the whole mock -/// member method call. This API is more flexible but requires more knowledge of -/// the AST structure of EXPECT_CALL macros. -internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockCall, - MockArgs Args); - -/// Like the first `gtestExpectCall` overload but for `ON_CALL`. -internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockObject, - llvm::StringRef MockMethodName, - MockArgs Args); - -/// Like the second `gtestExpectCall` overload but for `ON_CALL`. -internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockCall, - MockArgs Args); - -} // namespace ast_matchers -} // namespace clang - -#endif // LLVM_CLANG_ASTMATCHERS_GTESTMATCHERS_H - diff --git a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h index 9b53f1d..ea41eb3 100644 --- a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h +++ b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h @@ -14,6 +14,7 @@ #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H #define LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H +#include "clang/AST/ASTTypeTraits.h" #include "clang/AST/Decl.h" #include "clang/AST/Expr.h" #include "clang/AST/Stmt.h" @@ -139,6 +140,12 @@ public: FixItList &&Fixes, const Decl *D, const FixitStrategy &VarTargetTypes) = 0; + // Invoked when an array subscript operator[] is used on a + // std::unique_ptr<T[]>. + virtual void handleUnsafeUniquePtrArrayAccess(const DynTypedNode &Node, + bool IsRelatedToDecl, + ASTContext &Ctx) = 0; + #ifndef NDEBUG public: bool areDebugNotesRequested() { diff --git a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def index 09fa510..fae5f8b 100644 --- a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def +++ b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def @@ -38,6 +38,7 @@ WARNING_GADGET(PointerArithmetic) WARNING_GADGET(UnsafeBufferUsageAttr) WARNING_GADGET(UnsafeBufferUsageCtorAttr) WARNING_GADGET(DataInvocation) +WARNING_GADGET(UniquePtrArrayAccess) WARNING_OPTIONAL_GADGET(UnsafeLibcFunctionCall) WARNING_OPTIONAL_GADGET(SpanTwoParamConstructor) // Uses of `std::span(arg0, arg1)` FIXABLE_GADGET(ULCArraySubscript) // `DRE[any]` in an Unspecified Lvalue Context diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index 3c697ed..3cde249 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -4944,6 +4944,7 @@ def HLSLResourceBinding: InheritableAttr { std::optional<unsigned> SlotNumber; unsigned SpaceNumber; std::optional<unsigned> ImplicitBindingOrderID; + std::optional<unsigned> ImplicitCounterBindingOrderID; public: void setBinding(RegisterType RT, std::optional<unsigned> SlotNum, unsigned SpaceNum) { @@ -4976,6 +4977,17 @@ def HLSLResourceBinding: InheritableAttr { assert(hasImplicitBindingOrderID() && "attribute does not have implicit binding order id"); return ImplicitBindingOrderID.value(); } + void setImplicitCounterBindingOrderID(uint32_t Value) { + assert(!hasImplicitCounterBindingOrderID() && "attribute already has implicit counter binding order id"); + ImplicitCounterBindingOrderID = Value; + } + bool hasImplicitCounterBindingOrderID() const { + return ImplicitCounterBindingOrderID.has_value(); + } + uint32_t getImplicitCounterBindingOrderID() const { + assert(hasImplicitCounterBindingOrderID() && "attribute does not have implicit counter binding order id"); + return ImplicitCounterBindingOrderID.value(); + } }]; } diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 468121f..792e2e0 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -4945,6 +4945,12 @@ def HLSLResourceHandleFromImplicitBinding : LangBuiltin<"HLSL_LANG"> { let Prototype = "void(...)"; } +def HLSLResourceCounterHandleFromImplicitBinding : LangBuiltin<"HLSL_LANG"> { + let Spellings = ["__builtin_hlsl_resource_counterhandlefromimplicitbinding"]; + let Attributes = [NoThrow, CustomTypeChecking]; + let Prototype = "void(...)"; +} + def HLSLResourceNonUniformIndex : LangBuiltin<"HLSL_LANG"> { let Spellings = ["__builtin_hlsl_resource_nonuniformindex"]; let Attributes = [NoThrow]; diff --git a/clang/include/clang/Basic/BuiltinsX86.td b/clang/include/clang/Basic/BuiltinsX86.td index 4165225..217589d 100644 --- a/clang/include/clang/Basic/BuiltinsX86.td +++ b/clang/include/clang/Basic/BuiltinsX86.td @@ -123,13 +123,16 @@ let Attributes = [Const, NoThrow, RequiredVectorWidth<128>] in { def Op#d128 : X86Builtin<"_Vector<4, int>(_Vector<4, int>, _Vector<4, int>)">; } - def pmaddubsw128 : X86Builtin<"_Vector<8, short>(_Vector<16, char>, _Vector<16, char>)">; def pmulhrsw128 : X86Builtin<"_Vector<8, short>(_Vector<8, short>, _Vector<8, short>)">; def pshufb128 : X86Builtin<"_Vector<16, char>(_Vector<16, char>, _Vector<16, char>)">; def psignb128 : X86Builtin<"_Vector<16, char>(_Vector<16, char>, _Vector<16, char>)">; def psignw128 : X86Builtin<"_Vector<8, short>(_Vector<8, short>, _Vector<8, short>)">; def psignd128 : X86Builtin<"_Vector<4, int>(_Vector<4, int>, _Vector<4, int>)">; } + + let Features = "ssse3", Attributes = [NoThrow, Const, Constexpr, RequiredVectorWidth<128>] in { + def pmaddubsw128 : X86Builtin<"_Vector<8, short>(_Vector<16, char>, _Vector<16, char>)">; + } } // AVX @@ -278,13 +281,14 @@ let Features = "sse2", Attributes = [NoThrow, Const, RequiredVectorWidth<128>] i def psllw128 : X86Builtin<"_Vector<8, short>(_Vector<8, short>, _Vector<8, short>)">; def pslld128 : X86Builtin<"_Vector<4, int>(_Vector<4, int>, _Vector<4, int>)">; def psllq128 : X86Builtin<"_Vector<2, long long int>(_Vector<2, long long int>, _Vector<2, long long int>)">; - def pmaddwd128 : X86Builtin<"_Vector<4, int>(_Vector<8, short>, _Vector<8, short>)">; def pslldqi128_byteshift : X86Builtin<"_Vector<16, char>(_Vector<16, char>, _Constant int)">; def psrldqi128_byteshift : X86Builtin<"_Vector<16, char>(_Vector<16, char>, _Constant int)">; } let Features = "sse2", Attributes = [NoThrow, Const, Constexpr, RequiredVectorWidth<128>] in { + def pmaddwd128 : X86Builtin<"_Vector<4, int>(_Vector<8, short>, _Vector<8, short>)">; + def pmuludq128 : X86Builtin<"_Vector<2, long long int>(_Vector<4, int>, _Vector<4, int>)">; def psllwi128 : X86Builtin<"_Vector<8, short>(_Vector<8, short>, int)">; @@ -581,8 +585,6 @@ let Features = "avx2", Attributes = [NoThrow, Const, RequiredVectorWidth<256>] i def phsubw256 : X86Builtin<"_Vector<16, short>(_Vector<16, short>, _Vector<16, short>)">; def phsubd256 : X86Builtin<"_Vector<8, int>(_Vector<8, int>, _Vector<8, int>)">; def phsubsw256 : X86Builtin<"_Vector<16, short>(_Vector<16, short>, _Vector<16, short>)">; - def pmaddubsw256 : X86Builtin<"_Vector<16, short>(_Vector<32, char>, _Vector<32, char>)">; - def pmaddwd256 : X86Builtin<"_Vector<8, int>(_Vector<16, short>, _Vector<16, short>)">; def pmovmskb256 : X86Builtin<"int(_Vector<32, char>)">; def pmulhrsw256 : X86Builtin<"_Vector<16, short>(_Vector<16, short>, _Vector<16, short>)">; def psadbw256 : X86Builtin<"_Vector<4, long long int>(_Vector<32, char>, _Vector<32, char>)">; @@ -619,6 +621,9 @@ let Features = "avx2", Attributes = [NoThrow, Const, Constexpr, RequiredVectorWi def pblendvb256 : X86Builtin<"_Vector<32, char>(_Vector<32, char>, _Vector<32, char>, _Vector<32, char>)">; + def pmaddubsw256 : X86Builtin<"_Vector<16, short>(_Vector<32, char>, _Vector<32, char>)">; + def pmaddwd256 : X86Builtin<"_Vector<8, int>(_Vector<16, short>, _Vector<16, short>)">; + def pmuldq256 : X86Builtin<"_Vector<4, long long int>(_Vector<8, int>, _Vector<8, int>)">; def pmuludq256 : X86Builtin<"_Vector<4, long long int>(_Vector<8, int>, _Vector<8, int>)">; @@ -1378,10 +1383,6 @@ let Features = "avx512f", Attributes = [NoThrow, Const, RequiredVectorWidth<512> def subps512 : X86Builtin<"_Vector<16, float>(_Vector<16, float>, _Vector<16, float>, _Constant int)">; } -let Features = "avx512bw", Attributes = [NoThrow, Const, RequiredVectorWidth<512>] in { - def pmaddubsw512 : X86Builtin<"_Vector<32, short>(_Vector<64, char>, _Vector<64, char>)">; - def pmaddwd512 : X86Builtin<"_Vector<16, int>(_Vector<32, short>, _Vector<32, short>)">; -} let Features = "avx512f", Attributes = [NoThrow, Const, RequiredVectorWidth<128>] in { def addss_round_mask : X86Builtin<"_Vector<4, float>(_Vector<4, float>, _Vector<4, float>, _Vector<4, float>, unsigned char, _Constant int)">; @@ -1999,6 +2000,8 @@ let Features = "avx512bw", Attributes = [NoThrow, Const, RequiredVectorWidth<512 } let Features = "avx512bw", Attributes = [NoThrow, Const, Constexpr, RequiredVectorWidth<512>] in { + def pmaddubsw512 : X86Builtin<"_Vector<32, short>(_Vector<64, char>, _Vector<64, char>)">; + def pmaddwd512 : X86Builtin<"_Vector<16, int>(_Vector<32, short>, _Vector<32, short>)">; def psllv32hi : X86Builtin<"_Vector<32, short>(_Vector<32, short>, _Vector<32, short>)">; def pshufhw512 : X86Builtin<"_Vector<32, short>(_Vector<32, short>, _Constant int)">; def pshuflw512 : X86Builtin<"_Vector<32, short>(_Vector<32, short>, _Constant int)">; diff --git a/clang/include/clang/Basic/CMakeLists.txt b/clang/include/clang/Basic/CMakeLists.txt index 8173600..cfd165e 100644 --- a/clang/include/clang/Basic/CMakeLists.txt +++ b/clang/include/clang/Basic/CMakeLists.txt @@ -159,6 +159,9 @@ clang_tablegen(arm_mve_builtin_aliases.inc -gen-arm-mve-builtin-aliases clang_tablegen(arm_sve_builtins.inc -gen-arm-sve-builtins SOURCE arm_sve.td TARGET ClangARMSveBuiltins) +clang_tablegen(arm_sve_builtins.json -gen-arm-sve-builtins-json + SOURCE arm_sve.td + TARGET ClangARMSveBuiltinsJSON) clang_tablegen(arm_sve_builtin_cg.inc -gen-arm-sve-builtin-codegen SOURCE arm_sve.td TARGET ClangARMSveBuiltinCG) @@ -174,6 +177,9 @@ clang_tablegen(arm_sve_streaming_attrs.inc -gen-arm-sve-streaming-attrs clang_tablegen(arm_sme_builtins.inc -gen-arm-sme-builtins SOURCE arm_sme.td TARGET ClangARMSmeBuiltins) +clang_tablegen(arm_sme_builtins.json -gen-arm-sme-builtins-json + SOURCE arm_sme.td + TARGET ClangARMSmeBuiltinsJSON) clang_tablegen(arm_sme_builtin_cg.inc -gen-arm-sme-builtin-codegen SOURCE arm_sme.td TARGET ClangARMSmeBuiltinCG) diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def index 872f73e..d924cb4 100644 --- a/clang/include/clang/Basic/CodeGenOptions.def +++ b/clang/include/clang/Basic/CodeGenOptions.def @@ -306,6 +306,8 @@ CODEGENOPT(SanitizeBinaryMetadataCovered, 1, 0, Benign) ///< Emit PCs for covere CODEGENOPT(SanitizeBinaryMetadataAtomics, 1, 0, Benign) ///< Emit PCs for atomic operations. CODEGENOPT(SanitizeBinaryMetadataUAR, 1, 0, Benign) ///< Emit PCs for start of functions ///< that are subject for use-after-return checking. +CODEGENOPT(SanitizeAllocTokenFastABI, 1, 0, Benign) ///< Use the AllocToken fast ABI. +CODEGENOPT(SanitizeAllocTokenExtended, 1, 0, Benign) ///< Extend coverage to custom allocation functions. CODEGENOPT(SanitizeStats , 1, 0, Benign) ///< Collect statistics for sanitizers. ENUM_CODEGENOPT(SanitizeDebugTrapReasons, SanitizeDebugTrapReasonKind, 2, SanitizeDebugTrapReasonKind::Detailed, Benign) ///< Control how "trap reasons" are emitted in debug info CODEGENOPT(SimplifyLibCalls , 1, 1, Benign) ///< Set when -fbuiltin is enabled. diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h index 5d5cf25..cae06c3 100644 --- a/clang/include/clang/Basic/CodeGenOptions.h +++ b/clang/include/clang/Basic/CodeGenOptions.h @@ -447,6 +447,10 @@ public: std::optional<double> AllowRuntimeCheckSkipHotCutoff; + /// Maximum number of allocation tokens (0 = no max), nullopt if none set (use + /// pass default). + std::optional<uint64_t> AllocTokenMax; + /// List of backend command-line options for -fembed-bitcode. std::vector<uint8_t> CmdArgs; diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td index 0c994e0..4b27a42 100644 --- a/clang/include/clang/Basic/DiagnosticGroups.td +++ b/clang/include/clang/Basic/DiagnosticGroups.td @@ -1750,7 +1750,8 @@ def ReadOnlyPlacementChecks : DiagGroup<"read-only-types">; // Warnings and fixes to support the "safe buffers" programming model. def UnsafeBufferUsageInContainer : DiagGroup<"unsafe-buffer-usage-in-container">; def UnsafeBufferUsageInLibcCall : DiagGroup<"unsafe-buffer-usage-in-libc-call">; -def UnsafeBufferUsage : DiagGroup<"unsafe-buffer-usage", [UnsafeBufferUsageInContainer, UnsafeBufferUsageInLibcCall]>; +def UnsafeBufferUsageInUniquePtrArrayAccess : DiagGroup<"unsafe-buffer-usage-in-unique-ptr-array-access">; +def UnsafeBufferUsage : DiagGroup<"unsafe-buffer-usage", [UnsafeBufferUsageInContainer, UnsafeBufferUsageInLibcCall, UnsafeBufferUsageInUniquePtrArrayAccess]>; // Warnings and notes InstallAPI verification. def InstallAPIViolation : DiagGroup<"installapi-violation">; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index b157cbb..5be63c0 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -13295,6 +13295,8 @@ def note_safe_buffer_usage_suggestions_disabled : Note< def warn_unsafe_buffer_usage_in_container : Warning< "the two-parameter std::span construction is unsafe as it can introduce mismatch between buffer size and the bound information">, InGroup<UnsafeBufferUsageInContainer>, DefaultIgnore; +def warn_unsafe_buffer_usage_unique_ptr_array_access : Warning<"direct access using operator[] on std::unique_ptr<T[]> is unsafe due to lack of bounds checking">, + InGroup<UnsafeBufferUsageInUniquePtrArrayAccess>, DefaultIgnore; #ifndef NDEBUG // Not a user-facing diagnostic. Useful for debugging false negatives in // -fsafe-buffer-usage-suggestions (i.e. lack of -Wunsafe-buffer-usage fixits). diff --git a/clang/include/clang/Basic/Sanitizers.def b/clang/include/clang/Basic/Sanitizers.def index 1d0e97c..da85431 100644 --- a/clang/include/clang/Basic/Sanitizers.def +++ b/clang/include/clang/Basic/Sanitizers.def @@ -195,6 +195,9 @@ SANITIZER_GROUP("bounds", Bounds, ArrayBounds | LocalBounds) // Scudo hardened allocator SANITIZER("scudo", Scudo) +// AllocToken +SANITIZER("alloc-token", AllocToken) + // Magic group, containing all sanitizers. For example, "-fno-sanitize=all" // can be used to disable all the sanitizers. SANITIZER_GROUP("all", All, ~SanitizerMask()) diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index 89b519e..11ad61f 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -374,6 +374,12 @@ public: resOperands, attrs); } + cir::CallOp createCallOp(mlir::Location loc, mlir::SymbolRefAttr callee, + mlir::ValueRange operands = mlir::ValueRange(), + llvm::ArrayRef<mlir::NamedAttribute> attrs = {}) { + return createCallOp(loc, callee, cir::VoidType(), operands, attrs); + } + cir::CallOp createTryCallOp( mlir::Location loc, mlir::SymbolRefAttr callee = mlir::SymbolRefAttr(), mlir::Type returnType = cir::VoidType(), diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td index 43832b7..bb62223 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td @@ -770,6 +770,51 @@ def CIR_VisibilityAttr : CIR_EnumAttr<CIR_VisibilityKind, "visibility"> { } //===----------------------------------------------------------------------===// +// GloblCtorAttr +//===----------------------------------------------------------------------===// + +class CIR_GlobalCtorDtor<string name, string attrMnemonic> + : CIR_Attr<"Global" # name, "global_" # attrMnemonic> { + let parameters = (ins "mlir::StringAttr":$name, "int":$priority); + + let skipDefaultBuilders = 1; + let builders = [ + AttrBuilder<(ins + "llvm::StringRef":$name, + CArg<"int", "65535">:$priority), [{ + return $_get($_ctxt, mlir::StringAttr::get($_ctxt, name), priority); + }]>, + AttrBuilderWithInferredContext<(ins + "mlir::StringAttr":$name, + CArg<"int", "65535">:$priority), [{ + return $_get(name.getContext(), name, priority); + }]> + ]; + + let assemblyFormat = [{ + `<` $name `,` $priority `>` + }]; + + let extraClassDeclaration = [{ + bool isDefaultPriority() const { + return getPriority() == getDefaultPriority(); + }; + + static int getDefaultPriority() { + return 65535; + } + }]; +} + +def CIR_GlobalCtorAttr : CIR_GlobalCtorDtor<"Ctor", "ctor"> { + let summary = "Marks a function as a global constructor"; + let description = [{ + Marks the function as a global constructor in the module's constructor list. + It will be executed before main() is called. + }]; +} + +//===----------------------------------------------------------------------===// // BitfieldInfoAttr //===----------------------------------------------------------------------===// diff --git a/clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h b/clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h index 417a226..5c6ce7a 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h @@ -14,6 +14,7 @@ #include "mlir/Dialect/DLTI/DLTI.h" #include "mlir/IR/BuiltinOps.h" +#include "clang/CIR/Dialect/IR/CIRTypes.h" namespace cir { @@ -81,6 +82,18 @@ public: } llvm::TypeSize getTypeSizeInBits(mlir::Type ty) const; + + llvm::TypeSize getPointerTypeSizeInBits(mlir::Type ty) const { + assert(mlir::isa<cir::PointerType>(ty) && + "This should only be called with a pointer type"); + return layout.getTypeSizeInBits(ty); + } + + mlir::Type getIntPtrType(mlir::Type ty) const { + assert(mlir::isa<cir::PointerType>(ty) && "Expected pointer type"); + return cir::IntType::get(ty.getContext(), getPointerTypeSizeInBits(ty), + false); + } }; } // namespace cir diff --git a/clang/include/clang/CIR/Dialect/IR/CIRDialect.td b/clang/include/clang/CIR/Dialect/IR/CIRDialect.td index 15d5fa0..feb08d60 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRDialect.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRDialect.td @@ -42,6 +42,7 @@ def CIR_Dialect : Dialect { static llvm::StringRef getNoThrowAttrName() { return "nothrow"; } static llvm::StringRef getSideEffectAttrName() { return "side_effect"; } static llvm::StringRef getModuleLevelAsmAttrName() { return "cir.module_asm"; } + static llvm::StringRef getGlobalCtorsAttrName() { return "cir.global_ctors"; } void registerAttributes(); void registerTypes(); diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h index f795800..ace2086 100644 --- a/clang/include/clang/CIR/MissingFeatures.h +++ b/clang/include/clang/CIR/MissingFeatures.h @@ -38,10 +38,8 @@ struct MissingFeatures { static bool opGlobalPartition() { return false; } static bool opGlobalUsedOrCompilerUsed() { return false; } static bool opGlobalAnnotations() { return false; } - static bool opGlobalDtorLowering() { return false; } - static bool opGlobalCtorAttr() { return false; } static bool opGlobalCtorPriority() { return false; } - static bool opGlobalCtorList() { return false; } + static bool opGlobalDtorList() { return false; } static bool setDSOLocal() { return false; } static bool setComdat() { return false; } @@ -81,9 +79,12 @@ struct MissingFeatures { static bool opFuncExtraAttrs() { return false; } static bool opFuncMaybeHandleStaticInExternC() { return false; } static bool opFuncMultipleReturnVals() { return false; } + static bool opFuncNoUnwind() { return false; } static bool opFuncOperandBundles() { return false; } static bool opFuncParameterAttributes() { return false; } + static bool opFuncReadOnly() { return false; } static bool opFuncSection() { return false; } + static bool opFuncWillReturn() { return false; } static bool setLLVMFunctionFEnvAttributes() { return false; } static bool setFunctionAttributes() { return false; } @@ -138,7 +139,6 @@ struct MissingFeatures { // RecordType static bool skippedLayout() { return false; } static bool astRecordDeclAttr() { return false; } - static bool recordZeroInitPadding() { return false; } static bool zeroSizeRecordMembers() { return false; } // Coroutines diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 60c4ad4..ec38231 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -2731,8 +2731,25 @@ def fsanitize_skip_hot_cutoff_EQ "(0.0 [default] = skip none; 1.0 = skip all). " "Argument format: <sanitizer1>=<value1>,<sanitizer2>=<value2>,...">; +defm sanitize_alloc_token_fast_abi : BoolOption<"f", "sanitize-alloc-token-fast-abi", + CodeGenOpts<"SanitizeAllocTokenFastABI">, DefaultFalse, + PosFlag<SetTrue, [], [ClangOption], "Use the AllocToken fast ABI">, + NegFlag<SetFalse, [], [ClangOption], "Use the default AllocToken ABI">>, + Group<f_clang_Group>; +defm sanitize_alloc_token_extended : BoolOption<"f", "sanitize-alloc-token-extended", + CodeGenOpts<"SanitizeAllocTokenExtended">, DefaultFalse, + PosFlag<SetTrue, [], [ClangOption], "Enable">, + NegFlag<SetFalse, [], [ClangOption], "Disable">, + BothFlags<[], [ClangOption], " extended coverage to custom allocation functions">>, + Group<f_clang_Group>; + } // end -f[no-]sanitize* flags +def falloc_token_max_EQ : Joined<["-"], "falloc-token-max=">, + Group<f_Group>, Visibility<[ClangOption, CC1Option]>, + MetaVarName<"<N>">, + HelpText<"Limit to maximum N allocation tokens (0 = no max)">; + def fallow_runtime_check_skip_hot_cutoff_EQ : Joined<["-"], "fallow-runtime-check-skip-hot-cutoff=">, Group<f_clang_Group>, @@ -4715,6 +4732,10 @@ def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>, HelpText<"Generate source-level debug information with dwarf version 4">; def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>, HelpText<"Generate source-level debug information with dwarf version 5">; +def gdwarf_6 + : Flag<["-"], "gdwarf-6">, + Group<g_Group>, + HelpText<"Generate source-level debug information with dwarf version 6">; } def gdwarf64 : Flag<["-"], "gdwarf64">, Group<g_Group>, Visibility<[ClangOption, CC1Option, CC1AsOption]>, diff --git a/clang/include/clang/Driver/SanitizerArgs.h b/clang/include/clang/Driver/SanitizerArgs.h index 2b72268..eea7897 100644 --- a/clang/include/clang/Driver/SanitizerArgs.h +++ b/clang/include/clang/Driver/SanitizerArgs.h @@ -75,6 +75,8 @@ class SanitizerArgs { llvm::AsanDetectStackUseAfterReturnMode::Invalid; std::string MemtagMode; + bool AllocTokenFastABI = false; + bool AllocTokenExtended = false; public: /// Parses the sanitizer arguments from an argument list. diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 265462a..37598f8 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -10208,15 +10208,12 @@ public: bool CStyle, bool &ObjCLifetimeConversion); /// Determine whether the conversion from FromType to ToType is a valid - /// conversion that strips "noexcept" or "noreturn" or "cfi_unchecked_callee" - /// off the nested function type. This also checks if "cfi_unchecked_callee" - /// was added to the function type. If "cfi_unchecked_callee" is added and - /// `AddingCFIUncheckedCallee` is provided, it will be set to true. The same - /// thing applies for `DiscardingCFIUncheckedCallee` if the attribute is - /// discarded. - bool IsFunctionConversion(QualType FromType, QualType ToType, - bool *DiscardingCFIUncheckedCallee = nullptr, - bool *AddingCFIUncheckedCallee = nullptr) const; + /// conversion of ExtInfo/ExtProtoInfo on the nested function type. + /// More precisely, this method checks whether FromType can be transformed + /// into an exact match for ToType, by transforming its extended function + /// type information in legal manner (e.g. by strictly stripping "noreturn" + /// or "noexcept", or by stripping "noescape" for arguments). + bool IsFunctionConversion(QualType FromType, QualType ToType) const; /// Same as `IsFunctionConversion`, but if this would return true, it sets /// `ResultTy` to `ToType`. diff --git a/clang/lib/AST/ByteCode/InterpBuiltin.cpp b/clang/lib/AST/ByteCode/InterpBuiltin.cpp index 1eea813..922d679 100644 --- a/clang/lib/AST/ByteCode/InterpBuiltin.cpp +++ b/clang/lib/AST/ByteCode/InterpBuiltin.cpp @@ -678,30 +678,6 @@ static bool interp__builtin_popcount(InterpState &S, CodePtr OpPC, return true; } -static bool interp__builtin_parity(InterpState &S, CodePtr OpPC, - const InterpFrame *Frame, - const CallExpr *Call) { - APSInt Val = popToAPSInt(S, Call->getArg(0)); - pushInteger(S, Val.popcount() % 2, Call->getType()); - return true; -} - -static bool interp__builtin_clrsb(InterpState &S, CodePtr OpPC, - const InterpFrame *Frame, - const CallExpr *Call) { - APSInt Val = popToAPSInt(S, Call->getArg(0)); - pushInteger(S, Val.getBitWidth() - Val.getSignificantBits(), Call->getType()); - return true; -} - -static bool interp__builtin_bitreverse(InterpState &S, CodePtr OpPC, - const InterpFrame *Frame, - const CallExpr *Call) { - APSInt Val = popToAPSInt(S, Call->getArg(0)); - pushInteger(S, Val.reverseBits(), Call->getType()); - return true; -} - static bool interp__builtin_classify_type(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call) { @@ -736,16 +712,6 @@ static bool interp__builtin_expect(InterpState &S, CodePtr OpPC, return true; } -static bool interp__builtin_ffs(InterpState &S, CodePtr OpPC, - const InterpFrame *Frame, - const CallExpr *Call) { - APSInt Value = popToAPSInt(S, Call->getArg(0)); - - uint64_t N = Value.countr_zero(); - pushInteger(S, N == Value.getBitWidth() ? 0 : N + 1, Call->getType()); - return true; -} - static bool interp__builtin_addressof(InterpState &S, CodePtr OpPC, const InterpFrame *Frame, const CallExpr *Call) { @@ -2583,9 +2549,11 @@ static bool interp__builtin_elementwise_maxmin(InterpState &S, CodePtr OpPC, return true; } -static bool interp__builtin_ia32_pmul(InterpState &S, CodePtr OpPC, - const CallExpr *Call, - unsigned BuiltinID) { +static bool interp__builtin_ia32_pmul( + InterpState &S, CodePtr OpPC, const CallExpr *Call, + llvm::function_ref<APInt(const APSInt &, const APSInt &, const APSInt &, + const APSInt &)> + Fn) { assert(Call->getArg(0)->getType()->isVectorType() && Call->getArg(1)->getType()->isVectorType()); const Pointer &RHS = S.Stk.pop<Pointer>(); @@ -2594,35 +2562,23 @@ static bool interp__builtin_ia32_pmul(InterpState &S, CodePtr OpPC, const auto *VT = Call->getArg(0)->getType()->castAs<VectorType>(); PrimType ElemT = *S.getContext().classify(VT->getElementType()); - unsigned SourceLen = VT->getNumElements(); + unsigned NumElems = VT->getNumElements(); + const auto *DestVT = Call->getType()->castAs<VectorType>(); + PrimType DestElemT = *S.getContext().classify(DestVT->getElementType()); + bool DestUnsigned = Call->getType()->isUnsignedIntegerOrEnumerationType(); - PrimType DstElemT = *S.getContext().classify( - Call->getType()->castAs<VectorType>()->getElementType()); unsigned DstElem = 0; - for (unsigned I = 0; I != SourceLen; I += 2) { - APSInt Elem1; - APSInt Elem2; + for (unsigned I = 0; I != NumElems; I += 2) { + APSInt Result; INT_TYPE_SWITCH_NO_BOOL(ElemT, { - Elem1 = LHS.elem<T>(I).toAPSInt(); - Elem2 = RHS.elem<T>(I).toAPSInt(); + APSInt LoLHS = LHS.elem<T>(I).toAPSInt(); + APSInt HiLHS = LHS.elem<T>(I + 1).toAPSInt(); + APSInt LoRHS = RHS.elem<T>(I).toAPSInt(); + APSInt HiRHS = RHS.elem<T>(I + 1).toAPSInt(); + Result = APSInt(Fn(LoLHS, HiLHS, LoRHS, HiRHS), DestUnsigned); }); - APSInt Result; - switch (BuiltinID) { - case clang::X86::BI__builtin_ia32_pmuludq128: - case clang::X86::BI__builtin_ia32_pmuludq256: - case clang::X86::BI__builtin_ia32_pmuludq512: - Result = APSInt(llvm::APIntOps::muluExtended(Elem1, Elem2), - /*IsUnsigned=*/true); - break; - case clang::X86::BI__builtin_ia32_pmuldq128: - case clang::X86::BI__builtin_ia32_pmuldq256: - case clang::X86::BI__builtin_ia32_pmuldq512: - Result = APSInt(llvm::APIntOps::mulsExtended(Elem1, Elem2), - /*IsUnsigned=*/false); - break; - } - INT_TYPE_SWITCH_NO_BOOL(DstElemT, + INT_TYPE_SWITCH_NO_BOOL(DestElemT, { Dst.elem<T>(DstElem) = static_cast<T>(Result); }); ++DstElem; } @@ -3158,18 +3114,25 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, case Builtin::BI__builtin_parity: case Builtin::BI__builtin_parityl: case Builtin::BI__builtin_parityll: - return interp__builtin_parity(S, OpPC, Frame, Call); - + return interp__builtin_elementwise_int_unaryop( + S, OpPC, Call, [](const APSInt &Val) -> APInt { + return APInt(Val.getBitWidth(), Val.popcount() % 2); + }); case Builtin::BI__builtin_clrsb: case Builtin::BI__builtin_clrsbl: case Builtin::BI__builtin_clrsbll: - return interp__builtin_clrsb(S, OpPC, Frame, Call); - + return interp__builtin_elementwise_int_unaryop( + S, OpPC, Call, [](const APSInt &Val) -> APInt { + return APInt(Val.getBitWidth(), + Val.getBitWidth() - Val.getSignificantBits()); + }); case Builtin::BI__builtin_bitreverse8: case Builtin::BI__builtin_bitreverse16: case Builtin::BI__builtin_bitreverse32: case Builtin::BI__builtin_bitreverse64: - return interp__builtin_bitreverse(S, OpPC, Frame, Call); + return interp__builtin_elementwise_int_unaryop( + S, OpPC, Call, + [](const APSInt &Val) -> APInt { return Val.reverseBits(); }); case Builtin::BI__builtin_classify_type: return interp__builtin_classify_type(S, OpPC, Frame, Call); @@ -3209,7 +3172,11 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, case Builtin::BI__builtin_ffs: case Builtin::BI__builtin_ffsl: case Builtin::BI__builtin_ffsll: - return interp__builtin_ffs(S, OpPC, Frame, Call); + return interp__builtin_elementwise_int_unaryop( + S, OpPC, Call, [](const APSInt &Val) { + return APInt(Val.getBitWidth(), + Val.isZero() ? 0u : Val.countTrailingZeros() + 1u); + }); case Builtin::BIaddressof: case Builtin::BI__addressof: @@ -3494,6 +3461,30 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, return interp__builtin_elementwise_int_binop(S, OpPC, Call, llvm::APIntOps::avgCeilU); + case clang::X86::BI__builtin_ia32_pmaddubsw128: + case clang::X86::BI__builtin_ia32_pmaddubsw256: + case clang::X86::BI__builtin_ia32_pmaddubsw512: + return interp__builtin_ia32_pmul( + S, OpPC, Call, + [](const APSInt &LoLHS, const APSInt &HiLHS, const APSInt &LoRHS, + const APSInt &HiRHS) { + unsigned BitWidth = 2 * LoLHS.getBitWidth(); + return (LoLHS.zext(BitWidth) * LoRHS.sext(BitWidth)) + .sadd_sat((HiLHS.zext(BitWidth) * HiRHS.sext(BitWidth))); + }); + + case clang::X86::BI__builtin_ia32_pmaddwd128: + case clang::X86::BI__builtin_ia32_pmaddwd256: + case clang::X86::BI__builtin_ia32_pmaddwd512: + return interp__builtin_ia32_pmul( + S, OpPC, Call, + [](const APSInt &LoLHS, const APSInt &HiLHS, const APSInt &LoRHS, + const APSInt &HiRHS) { + unsigned BitWidth = 2 * LoLHS.getBitWidth(); + return (LoLHS.sext(BitWidth) * LoRHS.sext(BitWidth)) + + (HiLHS.sext(BitWidth) * HiRHS.sext(BitWidth)); + }); + case clang::X86::BI__builtin_ia32_pmulhuw128: case clang::X86::BI__builtin_ia32_pmulhuw256: case clang::X86::BI__builtin_ia32_pmulhuw512: @@ -3638,10 +3629,22 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, case clang::X86::BI__builtin_ia32_pmuldq128: case clang::X86::BI__builtin_ia32_pmuldq256: case clang::X86::BI__builtin_ia32_pmuldq512: + return interp__builtin_ia32_pmul( + S, OpPC, Call, + [](const APSInt &LoLHS, const APSInt &HiLHS, const APSInt &LoRHS, + const APSInt &HiRHS) { + return llvm::APIntOps::mulsExtended(LoLHS, LoRHS); + }); + case clang::X86::BI__builtin_ia32_pmuludq128: case clang::X86::BI__builtin_ia32_pmuludq256: case clang::X86::BI__builtin_ia32_pmuludq512: - return interp__builtin_ia32_pmul(S, OpPC, Call, BuiltinID); + return interp__builtin_ia32_pmul( + S, OpPC, Call, + [](const APSInt &LoLHS, const APSInt &HiLHS, const APSInt &LoRHS, + const APSInt &HiRHS) { + return llvm::APIntOps::muluExtended(LoLHS, LoRHS); + }); case Builtin::BI__builtin_elementwise_fma: return interp__builtin_elementwise_triop_fp( diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp index e5fba1b..c0be986 100644 --- a/clang/lib/AST/DeclTemplate.cpp +++ b/clang/lib/AST/DeclTemplate.cpp @@ -1653,57 +1653,65 @@ void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS, getValue().printPretty(OS, Policy, getType(), &getASTContext()); } -TemplateParameterList *clang::getReplacedTemplateParameterList(const Decl *D) { +std::tuple<NamedDecl *, TemplateArgument> +clang::getReplacedTemplateParameter(Decl *D, unsigned Index) { switch (D->getKind()) { - case Decl::Kind::CXXRecord: - return cast<CXXRecordDecl>(D) - ->getDescribedTemplate() - ->getTemplateParameters(); + case Decl::Kind::BuiltinTemplate: case Decl::Kind::ClassTemplate: - return cast<ClassTemplateDecl>(D)->getTemplateParameters(); + case Decl::Kind::Concept: + case Decl::Kind::FunctionTemplate: + case Decl::Kind::TemplateTemplateParm: + case Decl::Kind::TypeAliasTemplate: + case Decl::Kind::VarTemplate: + return {cast<TemplateDecl>(D)->getTemplateParameters()->getParam(Index), + {}}; case Decl::Kind::ClassTemplateSpecialization: { const auto *CTSD = cast<ClassTemplateSpecializationDecl>(D); auto P = CTSD->getSpecializedTemplateOrPartial(); + TemplateParameterList *TPL; if (const auto *CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl *>(P)) - return CTPSD->getTemplateParameters(); - return cast<ClassTemplateDecl *>(P)->getTemplateParameters(); + TPL = CTPSD->getTemplateParameters(); + else + TPL = cast<ClassTemplateDecl *>(P)->getTemplateParameters(); + return {TPL->getParam(Index), CTSD->getTemplateArgs()[Index]}; + } + case Decl::Kind::VarTemplateSpecialization: { + const auto *VTSD = cast<VarTemplateSpecializationDecl>(D); + auto P = VTSD->getSpecializedTemplateOrPartial(); + TemplateParameterList *TPL; + if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl *>(P)) + TPL = VTPSD->getTemplateParameters(); + else + TPL = cast<VarTemplateDecl *>(P)->getTemplateParameters(); + return {TPL->getParam(Index), VTSD->getTemplateArgs()[Index]}; } case Decl::Kind::ClassTemplatePartialSpecialization: - return cast<ClassTemplatePartialSpecializationDecl>(D) - ->getTemplateParameters(); - case Decl::Kind::TypeAliasTemplate: - return cast<TypeAliasTemplateDecl>(D)->getTemplateParameters(); - case Decl::Kind::BuiltinTemplate: - return cast<BuiltinTemplateDecl>(D)->getTemplateParameters(); + return {cast<ClassTemplatePartialSpecializationDecl>(D) + ->getTemplateParameters() + ->getParam(Index), + {}}; + case Decl::Kind::VarTemplatePartialSpecialization: + return {cast<VarTemplatePartialSpecializationDecl>(D) + ->getTemplateParameters() + ->getParam(Index), + {}}; + // This is used as the AssociatedDecl for placeholder type deduction. + case Decl::TemplateTypeParm: + return {cast<NamedDecl>(D), {}}; + // FIXME: Always use the template decl as the AssociatedDecl. + case Decl::Kind::CXXRecord: + return getReplacedTemplateParameter( + cast<CXXRecordDecl>(D)->getDescribedClassTemplate(), Index); case Decl::Kind::CXXDeductionGuide: case Decl::Kind::CXXConversion: case Decl::Kind::CXXConstructor: case Decl::Kind::CXXDestructor: case Decl::Kind::CXXMethod: case Decl::Kind::Function: - return cast<FunctionDecl>(D) - ->getTemplateSpecializationInfo() - ->getTemplate() - ->getTemplateParameters(); - case Decl::Kind::FunctionTemplate: - return cast<FunctionTemplateDecl>(D)->getTemplateParameters(); - case Decl::Kind::VarTemplate: - return cast<VarTemplateDecl>(D)->getTemplateParameters(); - case Decl::Kind::VarTemplateSpecialization: { - const auto *VTSD = cast<VarTemplateSpecializationDecl>(D); - auto P = VTSD->getSpecializedTemplateOrPartial(); - if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl *>(P)) - return VTPSD->getTemplateParameters(); - return cast<VarTemplateDecl *>(P)->getTemplateParameters(); - } - case Decl::Kind::VarTemplatePartialSpecialization: - return cast<VarTemplatePartialSpecializationDecl>(D) - ->getTemplateParameters(); - case Decl::Kind::TemplateTemplateParm: - return cast<TemplateTemplateParmDecl>(D)->getTemplateParameters(); - case Decl::Kind::Concept: - return cast<ConceptDecl>(D)->getTemplateParameters(); + return getReplacedTemplateParameter( + cast<FunctionDecl>(D)->getTemplateSpecializationInfo()->getTemplate(), + Index); default: llvm_unreachable("Unhandled templated declaration kind"); } diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp index 95de6a8..c7f0ff0 100644 --- a/clang/lib/AST/ExprCXX.cpp +++ b/clang/lib/AST/ExprCXX.cpp @@ -1727,7 +1727,7 @@ SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context, NonTypeTemplateParmDecl *SubstNonTypeTemplateParmExpr::getParameter() const { return cast<NonTypeTemplateParmDecl>( - getReplacedTemplateParameterList(getAssociatedDecl())->asArray()[Index]); + std::get<0>(getReplacedTemplateParameter(getAssociatedDecl(), Index))); } PackIndexingExpr *PackIndexingExpr::Create( @@ -1793,7 +1793,7 @@ SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr( NonTypeTemplateParmDecl * SubstNonTypeTemplateParmPackExpr::getParameterPack() const { return cast<NonTypeTemplateParmDecl>( - getReplacedTemplateParameterList(getAssociatedDecl())->asArray()[Index]); + std::get<0>(getReplacedTemplateParameter(getAssociatedDecl(), Index))); } TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const { diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 618e163..35a866e 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -11778,6 +11778,54 @@ bool VectorExprEvaluator::VisitCallExpr(const CallExpr *E) { case clang::X86::BI__builtin_ia32_pavgw512: return EvaluateBinOpExpr(llvm::APIntOps::avgCeilU); + case clang::X86::BI__builtin_ia32_pmaddubsw128: + case clang::X86::BI__builtin_ia32_pmaddubsw256: + case clang::X86::BI__builtin_ia32_pmaddubsw512: + case clang::X86::BI__builtin_ia32_pmaddwd128: + case clang::X86::BI__builtin_ia32_pmaddwd256: + case clang::X86::BI__builtin_ia32_pmaddwd512: { + APValue SourceLHS, SourceRHS; + if (!EvaluateAsRValue(Info, E->getArg(0), SourceLHS) || + !EvaluateAsRValue(Info, E->getArg(1), SourceRHS)) + return false; + + auto *DestTy = E->getType()->castAs<VectorType>(); + QualType DestEltTy = DestTy->getElementType(); + unsigned SourceLen = SourceLHS.getVectorLength(); + bool DestUnsigned = DestEltTy->isUnsignedIntegerOrEnumerationType(); + SmallVector<APValue, 4> ResultElements; + ResultElements.reserve(SourceLen / 2); + + for (unsigned EltNum = 0; EltNum < SourceLen; EltNum += 2) { + const APSInt &LoLHS = SourceLHS.getVectorElt(EltNum).getInt(); + const APSInt &HiLHS = SourceLHS.getVectorElt(EltNum + 1).getInt(); + const APSInt &LoRHS = SourceRHS.getVectorElt(EltNum).getInt(); + const APSInt &HiRHS = SourceRHS.getVectorElt(EltNum + 1).getInt(); + unsigned BitWidth = 2 * LoLHS.getBitWidth(); + + switch (E->getBuiltinCallee()) { + case clang::X86::BI__builtin_ia32_pmaddubsw128: + case clang::X86::BI__builtin_ia32_pmaddubsw256: + case clang::X86::BI__builtin_ia32_pmaddubsw512: + ResultElements.push_back(APValue( + APSInt((LoLHS.zext(BitWidth) * LoRHS.sext(BitWidth)) + .sadd_sat((HiLHS.zext(BitWidth) * HiRHS.sext(BitWidth))), + DestUnsigned))); + break; + case clang::X86::BI__builtin_ia32_pmaddwd128: + case clang::X86::BI__builtin_ia32_pmaddwd256: + case clang::X86::BI__builtin_ia32_pmaddwd512: + ResultElements.push_back( + APValue(APSInt((LoLHS.sext(BitWidth) * LoRHS.sext(BitWidth)) + + (HiLHS.sext(BitWidth) * HiRHS.sext(BitWidth)), + DestUnsigned))); + break; + } + } + + return Success(APValue(ResultElements.data(), ResultElements.size()), E); + } + case clang::X86::BI__builtin_ia32_pmulhuw128: case clang::X86::BI__builtin_ia32_pmulhuw256: case clang::X86::BI__builtin_ia32_pmulhuw512: diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index f3b5478..3cd033e 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -2769,10 +2769,19 @@ void OpenACCClauseProfiler::VisitReductionClause( for (auto &Recipe : Clause.getRecipes()) { Profiler.VisitDecl(Recipe.AllocaDecl); + // TODO: OpenACC: Make sure we remember to update this when we figure out // what we're adding for the operation recipe, in the meantime, a static // assert will make sure we don't add something. - static_assert(sizeof(OpenACCReductionRecipe) == sizeof(int *)); + static_assert(sizeof(OpenACCReductionRecipe::CombinerRecipe) == + 3 * sizeof(int *)); + for (auto &CombinerRecipe : Recipe.CombinerRecipes) { + if (CombinerRecipe.Op) { + Profiler.VisitDecl(CombinerRecipe.LHS); + Profiler.VisitDecl(CombinerRecipe.RHS); + Profiler.VisitStmt(CombinerRecipe.Op); + } + } } } diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp index 2b8044e..797a354 100644 --- a/clang/lib/AST/TemplateName.cpp +++ b/clang/lib/AST/TemplateName.cpp @@ -64,16 +64,14 @@ SubstTemplateTemplateParmPackStorage::getArgumentPack() const { TemplateTemplateParmDecl * SubstTemplateTemplateParmPackStorage::getParameterPack() const { - return cast<TemplateTemplateParmDecl>( - getReplacedTemplateParameterList(getAssociatedDecl()) - ->asArray()[Bits.Index]); + return cast<TemplateTemplateParmDecl>(std::get<0>( + getReplacedTemplateParameter(getAssociatedDecl(), Bits.Index))); } TemplateTemplateParmDecl * SubstTemplateTemplateParmStorage::getParameter() const { - return cast<TemplateTemplateParmDecl>( - getReplacedTemplateParameterList(getAssociatedDecl()) - ->asArray()[Bits.Index]); + return cast<TemplateTemplateParmDecl>(std::get<0>( + getReplacedTemplateParameter(getAssociatedDecl(), Bits.Index))); } void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) { diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 9794314..ee7a68e 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -4436,14 +4436,6 @@ IdentifierInfo *TemplateTypeParmType::getIdentifier() const { return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier(); } -static const TemplateTypeParmDecl *getReplacedParameter(Decl *D, - unsigned Index) { - if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) - return TTP; - return cast<TemplateTypeParmDecl>( - getReplacedTemplateParameterList(D)->getParam(Index)); -} - SubstTemplateTypeParmType::SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, @@ -4466,7 +4458,8 @@ SubstTemplateTypeParmType::SubstTemplateTypeParmType(QualType Replacement, const TemplateTypeParmDecl * SubstTemplateTypeParmType::getReplacedParameter() const { - return ::getReplacedParameter(getAssociatedDecl(), getIndex()); + return cast<TemplateTypeParmDecl>(std::get<0>( + getReplacedTemplateParameter(getAssociatedDecl(), getIndex()))); } void SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID, @@ -4532,7 +4525,8 @@ bool SubstTemplateTypeParmPackType::getFinal() const { const TemplateTypeParmDecl * SubstTemplateTypeParmPackType::getReplacedParameter() const { - return ::getReplacedParameter(getAssociatedDecl(), getIndex()); + return cast<TemplateTypeParmDecl>(std::get<0>( + getReplacedTemplateParameter(getAssociatedDecl(), getIndex()))); } IdentifierInfo *SubstTemplateTypeParmPackType::getIdentifier() const { diff --git a/clang/lib/ASTMatchers/CMakeLists.txt b/clang/lib/ASTMatchers/CMakeLists.txt index 7769fd6..29ad27df 100644 --- a/clang/lib/ASTMatchers/CMakeLists.txt +++ b/clang/lib/ASTMatchers/CMakeLists.txt @@ -8,7 +8,6 @@ set(LLVM_LINK_COMPONENTS add_clang_library(clangASTMatchers ASTMatchFinder.cpp ASTMatchersInternal.cpp - GtestMatchers.cpp LowLevelHelpers.cpp LINK_LIBS diff --git a/clang/lib/ASTMatchers/GtestMatchers.cpp b/clang/lib/ASTMatchers/GtestMatchers.cpp deleted file mode 100644 index 7c135bb..0000000 --- a/clang/lib/ASTMatchers/GtestMatchers.cpp +++ /dev/null @@ -1,228 +0,0 @@ -//===- GtestMatchers.cpp - AST Matchers for Gtest ---------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file implements several matchers for popular gtest macros. In general, -// AST matchers cannot match calls to macros. However, we can simulate such -// matches if the macro definition has identifiable elements that themselves can -// be matched. In that case, we can match on those elements and then check that -// the match occurs within an expansion of the desired macro. The more uncommon -// the identified elements, the more efficient this process will be. -// -//===----------------------------------------------------------------------===// - -#include "clang/ASTMatchers/GtestMatchers.h" -#include "llvm/ADT/StringRef.h" - -namespace clang { -namespace ast_matchers { -namespace { - -enum class MacroType { - Expect, - Assert, - On, -}; - -} // namespace - -static DeclarationMatcher getComparisonDecl(GtestCmp Cmp) { - switch (Cmp) { - case GtestCmp::Eq: - return cxxMethodDecl(hasName("Compare"), - ofClass(cxxRecordDecl(isSameOrDerivedFrom( - hasName("::testing::internal::EqHelper"))))); - case GtestCmp::Ne: - return functionDecl(hasName("::testing::internal::CmpHelperNE")); - case GtestCmp::Ge: - return functionDecl(hasName("::testing::internal::CmpHelperGE")); - case GtestCmp::Gt: - return functionDecl(hasName("::testing::internal::CmpHelperGT")); - case GtestCmp::Le: - return functionDecl(hasName("::testing::internal::CmpHelperLE")); - case GtestCmp::Lt: - return functionDecl(hasName("::testing::internal::CmpHelperLT")); - } - llvm_unreachable("Unhandled GtestCmp enum"); -} - -static llvm::StringRef getMacroTypeName(MacroType Macro) { - switch (Macro) { - case MacroType::Expect: - return "EXPECT"; - case MacroType::Assert: - return "ASSERT"; - case MacroType::On: - return "ON"; - } - llvm_unreachable("Unhandled MacroType enum"); -} - -static llvm::StringRef getComparisonTypeName(GtestCmp Cmp) { - switch (Cmp) { - case GtestCmp::Eq: - return "EQ"; - case GtestCmp::Ne: - return "NE"; - case GtestCmp::Ge: - return "GE"; - case GtestCmp::Gt: - return "GT"; - case GtestCmp::Le: - return "LE"; - case GtestCmp::Lt: - return "LT"; - } - llvm_unreachable("Unhandled GtestCmp enum"); -} - -static std::string getMacroName(MacroType Macro, GtestCmp Cmp) { - return (getMacroTypeName(Macro) + "_" + getComparisonTypeName(Cmp)).str(); -} - -static std::string getMacroName(MacroType Macro, llvm::StringRef Operation) { - return (getMacroTypeName(Macro) + "_" + Operation).str(); -} - -// Under the hood, ON_CALL is expanded to a call to `InternalDefaultActionSetAt` -// to set a default action spec to the underlying function mocker, while -// EXPECT_CALL is expanded to a call to `InternalExpectedAt` to set a new -// expectation spec. -static llvm::StringRef getSpecSetterName(MacroType Macro) { - switch (Macro) { - case MacroType::On: - return "InternalDefaultActionSetAt"; - case MacroType::Expect: - return "InternalExpectedAt"; - default: - llvm_unreachable("Unhandled MacroType enum"); - } - llvm_unreachable("Unhandled MacroType enum"); -} - -// In general, AST matchers cannot match calls to macros. However, we can -// simulate such matches if the macro definition has identifiable elements that -// themselves can be matched. In that case, we can match on those elements and -// then check that the match occurs within an expansion of the desired -// macro. The more uncommon the identified elements, the more efficient this -// process will be. -// -// We use this approach to implement the derived matchers gtestAssert and -// gtestExpect. -static internal::BindableMatcher<Stmt> -gtestComparisonInternal(MacroType Macro, GtestCmp Cmp, StatementMatcher Left, - StatementMatcher Right) { - return callExpr(isExpandedFromMacro(getMacroName(Macro, Cmp)), - callee(getComparisonDecl(Cmp)), hasArgument(2, Left), - hasArgument(3, Right)); -} - -static internal::BindableMatcher<Stmt> -gtestThatInternal(MacroType Macro, StatementMatcher Actual, - StatementMatcher Matcher) { - return cxxOperatorCallExpr( - isExpandedFromMacro(getMacroName(Macro, "THAT")), - hasOverloadedOperatorName("()"), hasArgument(2, Actual), - hasArgument( - 0, expr(hasType(classTemplateSpecializationDecl(hasName( - "::testing::internal::PredicateFormatterFromMatcher"))), - ignoringImplicit( - callExpr(callee(functionDecl(hasName( - "::testing::internal::" - "MakePredicateFormatterFromMatcher"))), - hasArgument(0, ignoringImplicit(Matcher))))))); -} - -static internal::BindableMatcher<Stmt> -gtestCallInternal(MacroType Macro, StatementMatcher MockCall, MockArgs Args) { - // A ON_CALL or EXPECT_CALL macro expands to different AST structures - // depending on whether the mock method has arguments or not. - switch (Args) { - // For example, - // `ON_CALL(mock, TwoParamMethod)` is expanded to - // `mock.gmock_TwoArgsMethod(WithoutMatchers(), - // nullptr).InternalDefaultActionSetAt(...)`. - // EXPECT_CALL is the same except - // that it calls `InternalExpectedAt` instead of `InternalDefaultActionSetAt` - // in the end. - case MockArgs::None: - return cxxMemberCallExpr( - isExpandedFromMacro(getMacroName(Macro, "CALL")), - callee(functionDecl(hasName(getSpecSetterName(Macro)))), - onImplicitObjectArgument(ignoringImplicit(MockCall))); - // For example, - // `ON_CALL(mock, TwoParamMethod(m1, m2))` is expanded to - // `mock.gmock_TwoParamMethod(m1,m2)(WithoutMatchers(), - // nullptr).InternalDefaultActionSetAt(...)`. - // EXPECT_CALL is the same except that it calls `InternalExpectedAt` instead - // of `InternalDefaultActionSetAt` in the end. - case MockArgs::Some: - return cxxMemberCallExpr( - isExpandedFromMacro(getMacroName(Macro, "CALL")), - callee(functionDecl(hasName(getSpecSetterName(Macro)))), - onImplicitObjectArgument(ignoringImplicit(cxxOperatorCallExpr( - hasOverloadedOperatorName("()"), argumentCountIs(3), - hasArgument(0, ignoringImplicit(MockCall)))))); - } - llvm_unreachable("Unhandled MockArgs enum"); -} - -static internal::BindableMatcher<Stmt> -gtestCallInternal(MacroType Macro, StatementMatcher MockObject, - llvm::StringRef MockMethodName, MockArgs Args) { - return gtestCallInternal( - Macro, - cxxMemberCallExpr( - onImplicitObjectArgument(MockObject), - callee(functionDecl(hasName(("gmock_" + MockMethodName).str())))), - Args); -} - -internal::BindableMatcher<Stmt> gtestAssert(GtestCmp Cmp, StatementMatcher Left, - StatementMatcher Right) { - return gtestComparisonInternal(MacroType::Assert, Cmp, Left, Right); -} - -internal::BindableMatcher<Stmt> gtestExpect(GtestCmp Cmp, StatementMatcher Left, - StatementMatcher Right) { - return gtestComparisonInternal(MacroType::Expect, Cmp, Left, Right); -} - -internal::BindableMatcher<Stmt> gtestAssertThat(StatementMatcher Actual, - StatementMatcher Matcher) { - return gtestThatInternal(MacroType::Assert, Actual, Matcher); -} - -internal::BindableMatcher<Stmt> gtestExpectThat(StatementMatcher Actual, - StatementMatcher Matcher) { - return gtestThatInternal(MacroType::Expect, Actual, Matcher); -} - -internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockObject, - llvm::StringRef MockMethodName, - MockArgs Args) { - return gtestCallInternal(MacroType::On, MockObject, MockMethodName, Args); -} - -internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockCall, - MockArgs Args) { - return gtestCallInternal(MacroType::On, MockCall, Args); -} - -internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockObject, - llvm::StringRef MockMethodName, - MockArgs Args) { - return gtestCallInternal(MacroType::Expect, MockObject, MockMethodName, Args); -} - -internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockCall, - MockArgs Args) { - return gtestCallInternal(MacroType::Expect, MockCall, Args); -} - -} // end namespace ast_matchers -} // end namespace clang diff --git a/clang/lib/Analysis/ExprMutationAnalyzer.cpp b/clang/lib/Analysis/ExprMutationAnalyzer.cpp index 3fcd348..1e376da 100644 --- a/clang/lib/Analysis/ExprMutationAnalyzer.cpp +++ b/clang/lib/Analysis/ExprMutationAnalyzer.cpp @@ -755,22 +755,23 @@ ExprMutationAnalyzer::Analyzer::findPointeeMemberMutation(const Expr *Exp) { const Stmt * ExprMutationAnalyzer::Analyzer::findPointeeToNonConst(const Expr *Exp) { - const auto NonConstPointerOrDependentType = - type(anyOf(nonConstPointerType(), isDependentType())); + const auto NonConstPointerOrNonConstRefOrDependentType = type( + anyOf(nonConstPointerType(), nonConstReferenceType(), isDependentType())); // assign const auto InitToNonConst = - varDecl(hasType(NonConstPointerOrDependentType), + varDecl(hasType(NonConstPointerOrNonConstRefOrDependentType), hasInitializer(expr(canResolveToExprPointee(Exp)).bind("stmt"))); - const auto AssignToNonConst = - binaryOperation(hasOperatorName("="), - hasLHS(expr(hasType(NonConstPointerOrDependentType))), - hasRHS(canResolveToExprPointee(Exp))); + const auto AssignToNonConst = binaryOperation( + hasOperatorName("="), + hasLHS(expr(hasType(NonConstPointerOrNonConstRefOrDependentType))), + hasRHS(canResolveToExprPointee(Exp))); // arguments like const auto ArgOfInstantiationDependent = allOf( hasAnyArgument(canResolveToExprPointee(Exp)), isInstantiationDependent()); - const auto ArgOfNonConstParameter = forEachArgumentWithParamType( - canResolveToExprPointee(Exp), NonConstPointerOrDependentType); + const auto ArgOfNonConstParameter = + forEachArgumentWithParamType(canResolveToExprPointee(Exp), + NonConstPointerOrNonConstRefOrDependentType); const auto CallLikeMatcher = anyOf(ArgOfNonConstParameter, ArgOfInstantiationDependent); const auto PassAsNonConstArg = @@ -779,9 +780,9 @@ ExprMutationAnalyzer::Analyzer::findPointeeToNonConst(const Expr *Exp) { parenListExpr(has(canResolveToExprPointee(Exp))), initListExpr(hasAnyInit(canResolveToExprPointee(Exp))))); // cast - const auto CastToNonConst = - explicitCastExpr(hasSourceExpression(canResolveToExprPointee(Exp)), - hasDestinationType(NonConstPointerOrDependentType)); + const auto CastToNonConst = explicitCastExpr( + hasSourceExpression(canResolveToExprPointee(Exp)), + hasDestinationType(NonConstPointerOrNonConstRefOrDependentType)); // capture // FIXME: false positive if the pointee does not change in lambda diff --git a/clang/lib/Analysis/LifetimeSafety.md b/clang/lib/Analysis/LifetimeSafety.md deleted file mode 100644 index 3f3d03d..0000000 --- a/clang/lib/Analysis/LifetimeSafety.md +++ /dev/null @@ -1,230 +0,0 @@ -Excellent! This is a very strong and logical structure for the white paper. It follows a clear narrative, starting from the high-level problem and progressively diving into the specifics of your solution. The sections on why a traditional borrow checker doesn't fit C++ and the open questions are particularly good, as they show a deep engagement with the problem space. - -Here is a draft of the white paper following your new skeleton, with the details filled in based on my analysis of your implementation and the provided reference documents. I've also incorporated some of my own suggestions to enhance the flow and clarity. - -*** - -<Disclaimer: Public document. This work is licensed under the Apache License v2.0 with LLVM Exceptions. See [https://llvm.org/LICENSE.txt](https://llvm.org/LICENSE.txt) for license information.> - -# Lifetime Safety: An Intuitive Approach for Temporal Safety in C++ -**Author:** -[Utkarsh Saxena](mailto:usx@google.com) - -**Purpose:** This document serves as a live RFC for a new lifetime safety analysis in C++, with the ultimate goal of publication as a white paper. - -## Intended Audience - -This document is intended for C++ compiler developers (especially those working on Clang), developers of other systems languages with advanced memory safety models (like Rust and Carbon), and all C++ users interested in writing safer code. - -## Goal - -* To describe a new lifetime model for C++ that aims to maximize the compile-time detection of temporal memory safety issues. -* To explore a path toward incremental safety in C++, offering a spectrum of checks that can be adopted without requiring a full plunge into a restrictive ownership model. - -**Out of Scope** - -* **Rigorous Temporal Memory Safety:** This analysis aims to detect a large class of common errors, but it does not formally prove the absence of all temporal safety bugs. -* **Runtime Solutions:** This paper focuses exclusively on static, compile-time analysis and does not cover runtime solutions like MTE or AddressSanitizer. - -# Paper: C++ Lifetimes Safety Analysis - -**Subtitle: A Flow-Sensitive, Alias-based Approach to Preventing Dangling Pointers** - -## Abstract - -This paper introduces a new intra-procedural, flow-sensitive lifetime analysis for C++ implemented in Clang. The analysis is designed to detect a significant class of temporal memory safety violations, such as use-after-free and use-after-return, at compile time. It is based on a model of "Loans" and "Origins," inspired by the Polonius borrow checker in Rust, but adapted for the semantics and flexibility of C++. - -The analysis works by translating the Clang CFG into a series of lifetime-relevant "Facts." These facts are then processed by dataflow analyses to precisely determine the validity of pointers and references at each program point. This fact-based approach, combined with a configurable strictness model, allows for both high-confidence error reporting and the detection of more subtle, potential bugs, without requiring extensive new annotations. The ultimate goal is to provide a powerful, low-overhead tool that makes C++ safer by default. - -## The Anatomy of a Temporal Safety Error - -At its core, a temporal safety error is a bug where an operation is performed on an object at a time when it is no longer valid to do so ([source](http://docs.google.com/document/d/19vbfAiV1yQu3xSMRWjyPUdzyB_LDdVUcKat_HWI1l3g?content_ref=at+its+core+a+temporal+safety+error+is+a+bug+where+an+operation+is+performed+on+an+object+at+a+time+when+it+is+no+longer+valid+to+do+so)). These bugs are notoriously difficult to debug because they often manifest as unpredictable crashes or silent data corruption far from the root cause. However, we can argue that this wide and varied class of errors—from use-after-free to iterator invalidation—all stem from a single, canonical pattern. - -**Conjecture: Any temporal safety issue is a form of Use-After-Free.** - -All sub-categories of temporal safety issues, such as returning a reference to a stack variable (`return-stack-addr`), using a variable after its scope has ended (`use-after-scope`), using heap memory after it has been deleted (`heap-use-after-free`), or using an iterator after its container has been modified (`use-after-invalidation`), can be described by a single sequence of events. - -In C++, an *object* is a region of storage, and pointers and references are the mechanisms we use to refer to them. A use-after-free occurs when we access an object after its lifetime has ended. But how can an object be accessed after it has been destroyed? This is only possible through an **alias**—a pointer or reference—that was created while the object was alive and that survived the object's destruction. - -This insight allows us to define a canonical use-after-free with four distinct events that happen in a specific order: - -1. **`t0`: Creation.** An object `M` is created in some region of storage (on the stack, on the heap, etc.). -2. **`t1`: Alias Creation.** An alias `P` (a pointer or reference) is created that refers to the object `M`. -3. **`t2`: End of Lifetime.** The lifetime of object `M` ends (e.g., it is deallocated, or it goes out of scope). -4. **`t3`: Use of Alias.** The alias `P`, which now dangles, is used to access the memory where `M` once resided. - -Let's examine this with a simple piece of C++ code: - -```cpp -void use_after_scope_example() { - int* p; - { - int s = 10; // t0: Object `s` is created on the stack. - p = &s; // t1: Alias `p` is made to refer to object `s`. - } // t2: The lifetime of `s` ends. `p` now dangles. - *p = 42; // t3: The dangling alias `p` is used. This is a use-after-free. -} -``` - -The fundamental problem is that the alias `p` outlived the object `s` it referred to. The challenge for a static analysis is therefore clear: to prevent temporal safety errors, the compiler must be able to track aliases and understand the lifetime of the objects they refer to. It needs to know the "points-to" set for every alias at every point in the program and verify that, at the moment of use, the alias does not point to an object whose lifetime has ended. - -This alias-based perspective is powerful because it generalizes beautifully. The "end of lifetime" event at `t2` doesn't have to be a variable going out of scope. It could be: - -* A call to `delete`, which ends the lifetime of a heap object. -* A function `return`, which ends the lifetime of all its local variables. -* A container modification, like `std::vector::push_back()`, which may reallocate storage, ending the lifetime of the objects in the old buffer and invalidating all existing iterators (aliases). - -By focusing on tracking aliases and their validity, we can build a unified model to detect a wide range of temporal safety errors without imposing the heavy "aliasing XOR mutability" restrictions of a traditional borrow checker ([source](https://gist.github.com/nmsmith/cdaa94aa74e8e0611221e65db8e41f7b?content_ref=the+major+advancement+is+to+eliminate+the+aliasing+xor+mutability+restriction+amongst+references+and+replace+it+with+a+similar+restriction+applied+to+lifetime+parameters)). This provides a more intuitive and C++-idiomatic path to memory safety. - -## Relation with Thread safety - -This analysis does not address Thread Safety. Thread safety is concerned with data races that occur across multiple threads. While it is possible to create temporal safety issues in multi-threaded scenarios, this analysis is focused on the sequential lifetime of objects within a single function. - -## Quest for Safer Aliasing - -Is it possible to achieve memory safety without a restrictive model like Rust's borrow checker? We believe the answer is yes. The key is to shift our focus from *restricting aliases* to *understanding them*. Instead of forbidding programs that have aliased mutable pointers, we can build a model that understands what each pointer can point to at any given time. This approach, similar to the one proposed in P1179 for C++ and explored in modern lifetime systems like Mojo's, allows us to directly detect the root cause of the problem: using a pointer after its target has ceased to exist ([source](http://docs.google.com/document/d/19vbfAiV1yQu3xSMRWjyPUdzyB_LDdVUcKat_HWI1l3g?content_ref=this+approach+similar+to+the+one+proposed+in+p1179+for+c+and+explored+in+modern+lifetime+systems+like+mojo+s+allows+us+to+directly+detect+the+root+cause+of+the+problem+using+a+pointer+after+its+target+has+ceased+to+exist)). - -This paper proposes such a model for C++. Let's begin with a simple, yet illustrative, dangling pointer bug: - -```cpp -// Example 1: A simple use-after-free -void definite_simple_case() { - MyObj* p; - { - MyObj s; - p = &s; // 'p' now points to 's' - } // 's' is destroyed, 'p' is now dangling - (void)*p; // Use-after-free -} -``` - -How can a compiler understand that the use of `p` is an error? It needs to answer a series of questions: - -1. What does `p` point to? -2. When does the object `p` points to cease to be valid? -3. Is `p` used after that point? - -Our model is designed to answer precisely these questions. - -## Core Concepts - -Our model is built on a few core concepts that allow us to formally track the relationships between pointers and the data they point to. - -### Access Paths - -An **Access Path** is a symbolic representation of a storage location in the program ([source](https://raw.githubusercontent.com/llvm/llvm-project/0e7c1732a9a7d28549fe5d690083daeb0e5de6b2/clang/lib/Analysis/LifetimeSafety.cpp?content_ref=struct+accesspath+const+clang+valuedecl+d+accesspath+const+clang+valuedecl+d+d+d)). It provides a way to uniquely identify a variable or a sub-object. For now, we will consider simple paths that refer to top-level variables, but the model can be extended to include field accesses (`a.b`), array elements (`a[i]`), and pointer indirections (`p->field`). - -### Loans: The Act of Borrowing - -A **Loan** is created whenever a reference or pointer to an object is created. It represents the act of "borrowing" that object's storage location ([source](https://raw.githubusercontent.com/llvm/llvm-project/0e7c1732a9a7d28549fe5d690083daeb0e5de6b2/clang/lib/Analysis/LifetimeSafety.cpp?content_ref=information+about+a+single+borrow+or+loan+a+loan+is+created+when+a+reference+or+pointer+is+created)). Each loan is associated with a unique ID and the `AccessPath` of the object being borrowed. - -In our `definite_simple_case` example, the expression `&s` creates a loan. The `AccessPath` for this loan is the variable `s`. - -### Origins: The Provenance of a Pointer - -An **Origin** is a symbolic identifier that represents the *set of possible loans* a pointer-like object could hold at any given time ([source](http://docs.google.com/document/d/1JpJ3M9yeXX-BnC4oKXBvRWzxoFrwziN1RzI4DrMrSp8?content_ref=ime+is+a+symbolic+identifier+representing+a+set+of+loans+from+which+a+pointer+or+reference+could+have+originated)). Every pointer-like variable or expression in the program is associated with an origin. - -* A variable declaration like `MyObj* p` introduces an origin for `p`. -* An expression like `&s` also has an origin. -* The complexity of origins can grow with type complexity. For example: - * `int* p;` has a single origin. - * `int** p;` has two origins: one for the outer pointer and one for the inner pointer. This allows us to distinguish between `p` itself being modified and what `*p` points to being modified. - * `struct S { int* p; };` also has an origin associated with the member `p`. - -The central goal of our analysis is to determine, for each origin at each point in the program, which loans it might contain. - -## Subtyping Rules and Subset Constraints - -The relationships between origins are established through the program's semantics, particularly assignments. When a pointer is assigned to another, as in `p = q`, the set of loans that `q` holds must be a subset of the loans that `p` can now hold. This is a fundamental subtyping rule: for `T*'a` to be a subtype of `T*'b`, the set of loans represented by `'a` must be a subset of the loans represented by `'b`. - -This leads to the concept of **subset constraints**. An assignment `p = q` generates a constraint `Origin(q) ⊆ Origin(p)`. The analysis doesn't solve these as a global system of equations. Instead, as we will see, it propagates the *consequences* of these constraints—the loans themselves—through the control-flow graph. This is a key departure from the Polonius model, which focuses on propagating the constraints (`'a: 'b`) themselves. - -## Invalidations: When Loans Expire - -A loan expires when the object it refers to is no longer valid. In our model, this is an **invalidation** event. The most common invalidation is deallocation, which in C++ can mean: -* A stack variable going out of scope. -* A `delete` call on a heap-allocated object. -* A container modification that reallocates its internal storage. - -## An Event-Based Representation of the Function - -To analyze a function, we first transform its CFG into a sequence of atomic, lifetime-relevant **Events**, which we call **Facts**. These facts abstract away the complexities of C++ syntax and provide a clean input for our analysis. The main facts are: - -* `Issue(LoanID, OriginID)`: A new loan is created. For example, `&s` generates an `Issue` fact. -* `Expire(LoanID)`: A loan expires. This is generated at the end of a variable's scope. -* `OriginFlow(Dest, Src, Kill)`: Loans from a source origin flow to a destination origin, as in an assignment. `Kill` indicates whether the destination's old loans are cleared. -* `Use(OriginID)`: An origin is used, such as in a pointer dereference. - -Let's trace our `definite_simple_case` example with these facts: - -```cpp -void definite_simple_case() { - MyObj* p; // Origin for p is O_p - { - MyObj s; - // The expression `&s` generates: - // - IssueFact(L1, O_&s) (A new loan L1 on 's' is created) - // The assignment `p = &s` generates: - // - OriginFlowFact(O_p, O_&s, Kill=true) - p = &s; - } // The end of the scope for 's' generates: - // - ExpireFact(L1) - // The dereference `*p` generates: - // - UseFact(O_p) - (void)*p; -} -``` - -## Flow-Sensitive Lifetime Policy - -With the program represented as a stream of facts, we can now define a flow-sensitive policy to answer our three core questions. We do this by maintaining a map from `Origin` to `Set<Loan>` at each program point. This map represents the state of our analysis. - -The analysis proceeds as follows: -1. **Forward Propagation of Loans:** We perform a forward dataflow analysis. - * When we encounter an `Issue` fact, we add the new loan to its origin's loan set. - * When we see an `OriginFlow` fact, we update the destination origin's loan set with the loans from the source. - * At control-flow merge points, we take the *union* of the loan sets from all incoming branches. - -2. **Backward Propagation of Liveness:** We then perform a backward dataflow analysis, starting from `Use` facts. - * A `Use` of an origin marks it as "live." - * This liveness information is propagated backward. If an origin `O_p` is live, and it received its loans from `O_q`, then `O_q` is also considered live at that point. - -3. **Error Detection:** An error is flagged when the analysis determines that a **live** origin contains a loan that has **expired**. - -In our `definite_simple_case` example: -* The forward analysis determines that at the point of use, `Origin(p)` contains `Loan(s)`. -* The backward analysis determines that at the point where `s` is destroyed, `Origin(p)` is live. -* The `ExpireFact` for `Loan(s)` occurs before the `UseFact`. -* The combination of these three conditions triggers a use-after-free error. - -## Without Functions, Our Work is Done Here! - -The model described so far works perfectly for a single, monolithic function. However, the moment we introduce function calls, the problem becomes more complex. How do we reason about lifetimes across function boundaries, especially when we can't see the implementation of the called function? - -### Effects of a Function Call - -A function call has inputs and outputs. From a lifetime perspective, the key challenge is to understand how the lifetimes of the outputs relate to the lifetimes of the inputs. - -### Outlives Constraints and Placeholder Origins - -When analyzing a function like `const char* get_prefix(const string& s, int len)`, we don't know the specific lifetime of the `s` that will be passed by the caller. To handle this, we introduce **placeholder origins** for the input parameters. These placeholders act as variables in our analysis. - -If a function returns a pointer or reference, its lifetime must be tied to one of its inputs. This is an **outlives constraint**. For example, the return value of `get_prefix` must "outlive" the input `s`. In our model, this means the origin of the return value will contain the placeholder loan associated with `s`. - -### Opaque Functions - -What if a function's implementation is not visible (e.g., it's in a separate translation unit), and it has no lifetime annotations? In this case, we must be conservative. If we pass a pointer to an opaque function, we have to assume it might have been invalidated. Our model handles this by associating a special **OPAQUE loan** with the pointer after the call, signifying that its lifetime is now unknown. - -## Why a Borrow Checker is Not the Right Fit for C++ - -The "aliasing XOR mutability" rule, while powerful, is fundamentally at odds with many idiomatic C++ patterns. -* **Observer Patterns:** It's common to have multiple non-owning pointers observing a mutable object. -* **Intrusive Data Structures:** Data structures like intrusive linked lists require objects to hold pointers to one another, creating cycles that are difficult for a traditional borrow checker to handle. -* **Iterator Invalidation:** The core problem in C++ is often not aliasing itself, but the fact that a mutation can invalidate an alias (e.g., resizing a vector). An alias-based analysis, like the one proposed here, directly models this problem, whereas a borrow checker can feel like an indirect and overly restrictive solution. - -By focusing on tracking what pointers can point to, our model avoids rejecting these safe and useful patterns, making it a more natural fit for the existing C++ ecosystem. - -## Open Questions - -* **When and if to introduce the term "lifetime"?** The term "lifetime" is heavily associated with Rust's model. This paper has intentionally focused on "Origins" and "Loans" to avoid confusion. Is there a point where introducing "lifetime" would be helpful, or should we stick to the new terminology? -* **Syntax for Annotations:** While this model is designed to work with minimal annotations, some will be necessary for complex cases. What should the syntax for these annotations look like? Can we build on existing attributes like `[[clang::lifetimebound]]`? diff --git a/clang/lib/Analysis/UnsafeBufferUsage.cpp b/clang/lib/Analysis/UnsafeBufferUsage.cpp index ad3d234..f5a3686 100644 --- a/clang/lib/Analysis/UnsafeBufferUsage.cpp +++ b/clang/lib/Analysis/UnsafeBufferUsage.cpp @@ -13,6 +13,7 @@ #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclTemplate.h" #include "clang/AST/DynamicRecursiveASTVisitor.h" #include "clang/AST/Expr.h" #include "clang/AST/FormatString.h" @@ -1318,6 +1319,97 @@ static bool isSupportedVariable(const DeclRefExpr &Node) { return D != nullptr && isa<VarDecl>(D); } +// Returns true for RecordDecl of type std::unique_ptr<T[]> +static bool isUniquePtrArray(const CXXRecordDecl *RecordDecl) { + if (!RecordDecl || !RecordDecl->isInStdNamespace() || + RecordDecl->getNameAsString() != "unique_ptr") + return false; + + const ClassTemplateSpecializationDecl *class_template_specialization_decl = + dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl); + if (!class_template_specialization_decl) + return false; + + const TemplateArgumentList &template_args = + class_template_specialization_decl->getTemplateArgs(); + if (template_args.size() == 0) + return false; + + const TemplateArgument &first_arg = template_args[0]; + if (first_arg.getKind() != TemplateArgument::Type) + return false; + + QualType referred_type = first_arg.getAsType(); + return referred_type->isArrayType(); +} + +class UniquePtrArrayAccessGadget : public WarningGadget { +private: + static constexpr const char *const AccessorTag = "unique_ptr_array_access"; + const CXXOperatorCallExpr *AccessorExpr; + +public: + UniquePtrArrayAccessGadget(const MatchResult &Result) + : WarningGadget(Kind::UniquePtrArrayAccess), + AccessorExpr(Result.getNodeAs<CXXOperatorCallExpr>(AccessorTag)) { + assert(AccessorExpr && + "UniquePtrArrayAccessGadget requires a matched CXXOperatorCallExpr"); + } + + static bool classof(const Gadget *G) { + return G->getKind() == Kind::UniquePtrArrayAccess; + } + + static bool matches(const Stmt *S, const ASTContext &Ctx, + MatchResult &Result) { + + const CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(S); + if (!OpCall || OpCall->getOperator() != OO_Subscript) + return false; + + const Expr *Callee = OpCall->getCallee()->IgnoreParenImpCasts(); + if (!Callee) + return false; + + const CXXMethodDecl *Method = + dyn_cast_or_null<CXXMethodDecl>(OpCall->getDirectCallee()); + if (!Method) + return false; + + if (Method->getOverloadedOperator() != OO_Subscript) + return false; + + const CXXRecordDecl *RecordDecl = Method->getParent(); + if (!isUniquePtrArray(RecordDecl)) + return false; + + const Expr *IndexExpr = OpCall->getArg(1); + clang::Expr::EvalResult Eval; + + // Allow [0] + if (IndexExpr->EvaluateAsInt(Eval, Ctx) && Eval.Val.getInt().isZero()) + return false; + + Result.addNode(AccessorTag, DynTypedNode::create(*OpCall)); + return true; + } + void handleUnsafeOperation(UnsafeBufferUsageHandler &Handler, + bool IsRelatedToDecl, + ASTContext &Ctx) const override { + Handler.handleUnsafeUniquePtrArrayAccess( + DynTypedNode::create(*AccessorExpr), IsRelatedToDecl, Ctx); + } + + SourceLocation getSourceLoc() const override { + if (AccessorExpr) + return AccessorExpr->getOperatorLoc(); + return SourceLocation(); + } + + DeclUseList getClaimedVarUseSites() const override { return {}; } + SmallVector<const Expr *, 1> getUnsafePtrs() const override { return {}; } +}; + using FixableGadgetList = std::vector<std::unique_ptr<FixableGadget>>; using WarningGadgetList = std::vector<std::unique_ptr<WarningGadget>>; @@ -2632,10 +2724,13 @@ std::set<const Expr *> clang::findUnsafePointers(const FunctionDecl *FD) { const VariableGroupsManager &, FixItList &&, const Decl *, const FixitStrategy &) override {} - bool isSafeBufferOptOut(const SourceLocation &) const override { + void handleUnsafeUniquePtrArrayAccess(const DynTypedNode &Node, + bool IsRelatedToDecl, + ASTContext &Ctx) override {} + bool ignoreUnsafeBufferInContainer(const SourceLocation &) const override { return false; } - bool ignoreUnsafeBufferInContainer(const SourceLocation &) const override { + bool isSafeBufferOptOut(const SourceLocation &) const override { return false; } bool ignoreUnsafeBufferInLibcCall(const SourceLocation &) const override { diff --git a/clang/lib/Basic/Diagnostic.cpp b/clang/lib/Basic/Diagnostic.cpp index 2b89370..8ecbd3c 100644 --- a/clang/lib/Basic/Diagnostic.cpp +++ b/clang/lib/Basic/Diagnostic.cpp @@ -517,12 +517,6 @@ public: const SourceManager &SM) const; private: - // Find the longest glob pattern that matches FilePath amongst - // CategoriesToMatchers, return true iff the match exists and belongs to a - // positive category. - bool globsMatches(const llvm::StringMap<Matcher> &CategoriesToMatchers, - StringRef FilePath) const; - llvm::DenseMap<diag::kind, const Section *> DiagToSection; }; } // namespace @@ -538,7 +532,7 @@ WarningsSpecialCaseList::create(const llvm::MemoryBuffer &Input, void WarningsSpecialCaseList::processSections(DiagnosticsEngine &Diags) { static constexpr auto WarningFlavor = clang::diag::Flavor::WarningOrError; - for (const auto &SectionEntry : Sections) { + for (const auto &SectionEntry : sections()) { StringRef DiagGroup = SectionEntry.SectionStr; if (DiagGroup == "*") { // Drop the default section introduced by special case list, we only @@ -584,43 +578,24 @@ void DiagnosticsEngine::setDiagSuppressionMapping(llvm::MemoryBuffer &Input) { bool WarningsSpecialCaseList::isDiagSuppressed(diag::kind DiagId, SourceLocation DiagLoc, const SourceManager &SM) const { + PresumedLoc PLoc = SM.getPresumedLoc(DiagLoc); + if (!PLoc.isValid()) + return false; const Section *DiagSection = DiagToSection.lookup(DiagId); if (!DiagSection) return false; - const SectionEntries &EntityTypeToCategories = DiagSection->Entries; - auto SrcEntriesIt = EntityTypeToCategories.find("src"); - if (SrcEntriesIt == EntityTypeToCategories.end()) + + StringRef F = llvm::sys::path::remove_leading_dotslash(PLoc.getFilename()); + + StringRef LongestSup = DiagSection->getLongestMatch("src", F, ""); + if (LongestSup.empty()) return false; - const llvm::StringMap<llvm::SpecialCaseList::Matcher> &CategoriesToMatchers = - SrcEntriesIt->getValue(); - // We also use presumed locations here to improve reproducibility for - // preprocessed inputs. - if (PresumedLoc PLoc = SM.getPresumedLoc(DiagLoc); PLoc.isValid()) - return globsMatches( - CategoriesToMatchers, - llvm::sys::path::remove_leading_dotslash(PLoc.getFilename())); - return false; -} -bool WarningsSpecialCaseList::globsMatches( - const llvm::StringMap<Matcher> &CategoriesToMatchers, - StringRef FilePath) const { - StringRef LongestMatch; - bool LongestIsPositive = false; - for (const auto &Entry : CategoriesToMatchers) { - StringRef Category = Entry.getKey(); - const llvm::SpecialCaseList::Matcher &Matcher = Entry.getValue(); - bool IsPositive = Category != "emit"; - for (const auto &Glob : Matcher.Globs) { - if (Glob->Name.size() < LongestMatch.size()) - continue; - if (!Glob->Pattern.match(FilePath)) - continue; - LongestMatch = Glob->Name; - LongestIsPositive = IsPositive; - } - } - return LongestIsPositive; + StringRef LongestEmit = DiagSection->getLongestMatch("src", F, "emit"); + if (LongestEmit.empty()) + return true; + + return LongestSup.size() > LongestEmit.size(); } bool DiagnosticsEngine::isSuppressedViaMapping(diag::kind DiagId, diff --git a/clang/lib/Basic/ProfileList.cpp b/clang/lib/Basic/ProfileList.cpp index 8481def..9cb1188 100644 --- a/clang/lib/Basic/ProfileList.cpp +++ b/clang/lib/Basic/ProfileList.cpp @@ -32,10 +32,10 @@ public: createOrDie(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &VFS); - bool isEmpty() const { return Sections.empty(); } + bool isEmpty() const { return sections().empty(); } bool hasPrefix(StringRef Prefix) const { - for (const auto &It : Sections) + for (const auto &It : sections()) if (It.Entries.count(Prefix) > 0) return true; return false; diff --git a/clang/lib/Basic/SanitizerSpecialCaseList.cpp b/clang/lib/Basic/SanitizerSpecialCaseList.cpp index 792000b..56f5516 100644 --- a/clang/lib/Basic/SanitizerSpecialCaseList.cpp +++ b/clang/lib/Basic/SanitizerSpecialCaseList.cpp @@ -38,7 +38,7 @@ SanitizerSpecialCaseList::createOrDie(const std::vector<std::string> &Paths, } void SanitizerSpecialCaseList::createSanitizerSections() { - for (const auto &S : Sections) { + for (const auto &S : sections()) { SanitizerMask Mask; #define SANITIZER(NAME, ID) \ diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index 58345b4..25afe8b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h @@ -122,6 +122,11 @@ public: return getPointerTo(cir::VPtrType::get(getContext())); } + cir::FuncType getFuncType(llvm::ArrayRef<mlir::Type> params, mlir::Type retTy, + bool isVarArg = false) { + return cir::FuncType::get(params, retTy, isVarArg); + } + /// Get a CIR record kind from a AST declaration tag. cir::RecordType::RecordKind getRecordKind(const clang::TagTypeKind kind) { switch (kind) { @@ -372,6 +377,15 @@ public: return cir::BinOp::create(*this, loc, cir::BinOpKind::Div, lhs, rhs); } + mlir::Value createDynCast(mlir::Location loc, mlir::Value src, + cir::PointerType destType, bool isRefCast, + cir::DynamicCastInfoAttr info) { + auto castKind = + isRefCast ? cir::DynamicCastKind::Ref : cir::DynamicCastKind::Ptr; + return cir::DynamicCastOp::create(*this, loc, destType, castKind, src, info, + /*relative_layout=*/false); + } + Address createBaseClassAddr(mlir::Location loc, Address addr, mlir::Type destType, unsigned offset, bool assumeNotNull) { diff --git a/clang/lib/CIR/CodeGen/CIRGenCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenCXX.cpp index d5b35c2..274d11b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCXX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCXX.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "CIRGenCXXABI.h" #include "CIRGenFunction.h" #include "CIRGenModule.h" @@ -95,7 +96,63 @@ static void emitDeclDestroy(CIRGenFunction &cgf, const VarDecl *vd, return; } - cgf.cgm.errorNYI(vd->getSourceRange(), "global with destructor"); + // If not constant storage we'll emit this regardless of NeedsDtor value. + CIRGenBuilderTy &builder = cgf.getBuilder(); + + // Prepare the dtor region. + mlir::OpBuilder::InsertionGuard guard(builder); + mlir::Block *block = builder.createBlock(&addr.getDtorRegion()); + CIRGenFunction::LexicalScope lexScope{cgf, addr.getLoc(), + builder.getInsertionBlock()}; + lexScope.setAsGlobalInit(); + builder.setInsertionPointToStart(block); + + CIRGenModule &cgm = cgf.cgm; + QualType type = vd->getType(); + + // Special-case non-array C++ destructors, if they have the right signature. + // Under some ABIs, destructors return this instead of void, and cannot be + // passed directly to __cxa_atexit if the target does not allow this + // mismatch. + const CXXRecordDecl *record = type->getAsCXXRecordDecl(); + bool canRegisterDestructor = + record && (!cgm.getCXXABI().hasThisReturn( + GlobalDecl(record->getDestructor(), Dtor_Complete)) || + cgm.getCXXABI().canCallMismatchedFunctionType()); + + // If __cxa_atexit is disabled via a flag, a different helper function is + // generated elsewhere which uses atexit instead, and it takes the destructor + // directly. + cir::FuncOp fnOp; + if (record && (canRegisterDestructor || cgm.getCodeGenOpts().CXAAtExit)) { + if (vd->getTLSKind()) + cgm.errorNYI(vd->getSourceRange(), "TLS destructor"); + assert(!record->hasTrivialDestructor()); + assert(!cir::MissingFeatures::openCL()); + CXXDestructorDecl *dtor = record->getDestructor(); + // In LLVM OG codegen this is done in registerGlobalDtor, but CIRGen + // relies on LoweringPrepare for further decoupling, so build the + // call right here. + auto gd = GlobalDecl(dtor, Dtor_Complete); + fnOp = cgm.getAddrAndTypeOfCXXStructor(gd).second; + cgf.getBuilder().createCallOp( + cgf.getLoc(vd->getSourceRange()), + mlir::FlatSymbolRefAttr::get(fnOp.getSymNameAttr()), + mlir::ValueRange{cgm.getAddrOfGlobalVar(vd)}); + } else { + cgm.errorNYI(vd->getSourceRange(), "array destructor"); + } + assert(fnOp && "expected cir.func"); + cgm.getCXXABI().registerGlobalDtor(vd, fnOp, nullptr); + + builder.setInsertionPointToEnd(block); + if (block->empty()) { + block->erase(); + // Don't confuse lexical cleanup. + builder.clearInsertionPoint(); + } else { + builder.create<cir::YieldOp>(addr.getLoc()); + } } cir::FuncOp CIRGenModule::codegenCXXStructor(GlobalDecl gd) { diff --git a/clang/lib/CIR/CodeGen/CIRGenCXXABI.h b/clang/lib/CIR/CodeGen/CIRGenCXXABI.h index 2465a68..06f41cd 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCXXABI.h +++ b/clang/lib/CIR/CodeGen/CIRGenCXXABI.h @@ -54,6 +54,12 @@ public: Address thisAddr, const CXXRecordDecl *classDecl, const CXXRecordDecl *baseClassDecl) = 0; + virtual mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc, + QualType srcRecordTy, + QualType destRecordTy, + cir::PointerType destCIRTy, + bool isRefCast, Address src) = 0; + public: /// Similar to AddedStructorArgs, but only notes the number of additional /// arguments. @@ -149,6 +155,14 @@ public: /// Loads the incoming C++ this pointer as it was passed by the caller. mlir::Value loadIncomingCXXThis(CIRGenFunction &cgf); + /// Get the implicit (second) parameter that comes after the "this" pointer, + /// or nullptr if there is isn't one. + virtual mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf, + const CXXDestructorDecl *dd, + CXXDtorType type, + bool forVirtualBase, + bool delegating) = 0; + /// Emit constructor variants required by this ABI. virtual void emitCXXConstructors(const clang::CXXConstructorDecl *d) = 0; @@ -160,6 +174,14 @@ public: bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy) = 0; + /// Emit code to force the execution of a destructor during global + /// teardown. The default implementation of this uses atexit. + /// + /// \param dtor - a function taking a single pointer argument + /// \param addr - a pointer to pass to the destructor function. + virtual void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor, + mlir::Value addr) = 0; + /// Checks if ABI requires extra virtual offset for vtable field. virtual bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf, @@ -233,6 +255,16 @@ public: return false; } + /// Returns true if the target allows calling a function through a pointer + /// with a different signature than the actual function (or equivalently, + /// bitcasting a function or function pointer to a different function type). + /// In principle in the most general case this could depend on the target, the + /// calling convention, and the actual types of the arguments and return + /// value. Here it just means whether the signature mismatch could *ever* be + /// allowed; in other words, does the target do strict checking of signatures + /// for all calls. + virtual bool canCallMismatchedFunctionType() const { return true; } + /// Gets the mangle context. clang::MangleContext &getMangleContext() { return *mangleContext; } diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp index 8f4377b..485b2c8 100644 --- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp @@ -126,6 +126,30 @@ static bool isInitializerOfDynamicClass(const CXXCtorInitializer *baseInit) { } namespace { +/// Call the destructor for a direct base class. +struct CallBaseDtor final : EHScopeStack::Cleanup { + const CXXRecordDecl *baseClass; + bool baseIsVirtual; + CallBaseDtor(const CXXRecordDecl *base, bool baseIsVirtual) + : baseClass(base), baseIsVirtual(baseIsVirtual) {} + + void emit(CIRGenFunction &cgf) override { + const CXXRecordDecl *derivedClass = + cast<CXXMethodDecl>(cgf.curFuncDecl)->getParent(); + + const CXXDestructorDecl *d = baseClass->getDestructor(); + // We are already inside a destructor, so presumably the object being + // destroyed should have the expected type. + QualType thisTy = d->getFunctionObjectParameterType(); + assert(cgf.currSrcLoc && "expected source location"); + Address addr = cgf.getAddressOfDirectBaseInCompleteClass( + *cgf.currSrcLoc, cgf.loadCXXThisAddress(), derivedClass, baseClass, + baseIsVirtual); + cgf.emitCXXDestructorCall(d, Dtor_Base, baseIsVirtual, + /*delegating=*/false, addr, thisTy); + } +}; + /// A visitor which checks whether an initializer uses 'this' in a /// way which requires the vtable to be properly set. struct DynamicThisUseChecker @@ -870,6 +894,116 @@ void CIRGenFunction::destroyCXXObject(CIRGenFunction &cgf, Address addr, /*delegating=*/false, addr, type); } +namespace { +class DestroyField final : public EHScopeStack::Cleanup { + const FieldDecl *field; + CIRGenFunction::Destroyer *destroyer; + +public: + DestroyField(const FieldDecl *field, CIRGenFunction::Destroyer *destroyer) + : field(field), destroyer(destroyer) {} + + void emit(CIRGenFunction &cgf) override { + // Find the address of the field. + Address thisValue = cgf.loadCXXThisAddress(); + CanQualType recordTy = + cgf.getContext().getCanonicalTagType(field->getParent()); + LValue thisLV = cgf.makeAddrLValue(thisValue, recordTy); + LValue lv = cgf.emitLValueForField(thisLV, field); + assert(lv.isSimple()); + + assert(!cir::MissingFeatures::ehCleanupFlags()); + cgf.emitDestroy(lv.getAddress(), field->getType(), destroyer); + } +}; +} // namespace + +/// Emit all code that comes at the end of class's destructor. This is to call +/// destructors on members and base classes in reverse order of their +/// construction. +/// +/// For a deleting destructor, this also handles the case where a destroying +/// operator delete completely overrides the definition. +void CIRGenFunction::enterDtorCleanups(const CXXDestructorDecl *dd, + CXXDtorType dtorType) { + assert((!dd->isTrivial() || dd->hasAttr<DLLExportAttr>()) && + "Should not emit dtor epilogue for non-exported trivial dtor!"); + + // The deleting-destructor phase just needs to call the appropriate + // operator delete that Sema picked up. + if (dtorType == Dtor_Deleting) { + cgm.errorNYI(dd->getSourceRange(), "deleting destructor cleanups"); + return; + } + + const CXXRecordDecl *classDecl = dd->getParent(); + + // Unions have no bases and do not call field destructors. + if (classDecl->isUnion()) + return; + + // The complete-destructor phase just destructs all the virtual bases. + if (dtorType == Dtor_Complete) { + assert(!cir::MissingFeatures::sanitizers()); + + // We push them in the forward order so that they'll be popped in + // the reverse order. + for (const CXXBaseSpecifier &base : classDecl->vbases()) { + auto *baseClassDecl = base.getType()->castAsCXXRecordDecl(); + + if (baseClassDecl->hasTrivialDestructor()) { + // Under SanitizeMemoryUseAfterDtor, poison the trivial base class + // memory. For non-trival base classes the same is done in the class + // destructor. + assert(!cir::MissingFeatures::sanitizers()); + } else { + ehStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup, baseClassDecl, + /*baseIsVirtual=*/true); + } + } + + return; + } + + assert(dtorType == Dtor_Base); + assert(!cir::MissingFeatures::sanitizers()); + + // Destroy non-virtual bases. + for (const CXXBaseSpecifier &base : classDecl->bases()) { + // Ignore virtual bases. + if (base.isVirtual()) + continue; + + CXXRecordDecl *baseClassDecl = base.getType()->getAsCXXRecordDecl(); + + if (baseClassDecl->hasTrivialDestructor()) + assert(!cir::MissingFeatures::sanitizers()); + else + ehStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup, baseClassDecl, + /*baseIsVirtual=*/false); + } + + assert(!cir::MissingFeatures::sanitizers()); + + // Destroy direct fields. + for (const FieldDecl *field : classDecl->fields()) { + QualType type = field->getType(); + QualType::DestructionKind dtorKind = type.isDestructedType(); + if (!dtorKind) + continue; + + // Anonymous union members do not have their destructors called. + const RecordType *rt = type->getAsUnionType(); + if (rt && rt->getOriginalDecl()->isAnonymousStructOrUnion()) + continue; + + CleanupKind cleanupKind = getCleanupKind(dtorKind); + assert(!cir::MissingFeatures::ehCleanupFlags()); + ehStack.pushCleanup<DestroyField>(cleanupKind, field, + getDestroyer(dtorKind)); + } +} + void CIRGenFunction::emitDelegatingCXXConstructorCall( const CXXConstructorDecl *ctor, const FunctionArgList &args) { assert(ctor->isDelegatingConstructor()); diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp index 563a753..039d290 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp @@ -695,12 +695,6 @@ struct DestroyObject final : EHScopeStack::Cleanup { void emit(CIRGenFunction &cgf) override { cgf.emitDestroy(addr, type, destroyer); } - - // This is a placeholder until EHCleanupScope is implemented. - size_t getSize() const override { - assert(!cir::MissingFeatures::ehCleanupScope()); - return sizeof(DestroyObject); - } }; } // namespace diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index be94890..f416571 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp @@ -1185,10 +1185,16 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *e) { case CK_BuiltinFnToFnPtr: llvm_unreachable("builtin functions are handled elsewhere"); + case CK_Dynamic: { + LValue lv = emitLValue(e->getSubExpr()); + Address v = lv.getAddress(); + const auto *dce = cast<CXXDynamicCastExpr>(e); + return makeNaturalAlignAddrLValue(emitDynamicCast(v, dce), e->getType()); + } + // These are never l-values; just use the aggregate emission code. case CK_NonAtomicToAtomic: case CK_AtomicToNonAtomic: - case CK_Dynamic: case CK_ToUnion: case CK_BaseToDerived: case CK_AddressSpaceConversion: diff --git a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp index 4eb8ca8..97c0944 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp @@ -463,12 +463,6 @@ struct CallObjectDelete final : EHScopeStack::Cleanup { void emit(CIRGenFunction &cgf) override { cgf.emitDeleteCall(operatorDelete, ptr, elementType); } - - // This is a placeholder until EHCleanupScope is implemented. - size_t getSize() const override { - assert(!cir::MissingFeatures::ehCleanupScope()); - return sizeof(CallObjectDelete); - } }; } // namespace @@ -728,3 +722,43 @@ void CIRGenFunction::emitDeleteCall(const FunctionDecl *deleteFD, // Emit the call to delete. emitNewDeleteCall(*this, deleteFD, deleteFTy, deleteArgs); } + +mlir::Value CIRGenFunction::emitDynamicCast(Address thisAddr, + const CXXDynamicCastExpr *dce) { + mlir::Location loc = getLoc(dce->getSourceRange()); + + cgm.emitExplicitCastExprType(dce, this); + QualType destTy = dce->getTypeAsWritten(); + QualType srcTy = dce->getSubExpr()->getType(); + + // C++ [expr.dynamic.cast]p7: + // If T is "pointer to cv void," then the result is a pointer to the most + // derived object pointed to by v. + bool isDynCastToVoid = destTy->isVoidPointerType(); + bool isRefCast = destTy->isReferenceType(); + + QualType srcRecordTy; + QualType destRecordTy; + if (isDynCastToVoid) { + srcRecordTy = srcTy->getPointeeType(); + // No destRecordTy. + } else if (const PointerType *destPTy = destTy->getAs<PointerType>()) { + srcRecordTy = srcTy->castAs<PointerType>()->getPointeeType(); + destRecordTy = destPTy->getPointeeType(); + } else { + srcRecordTy = srcTy; + destRecordTy = destTy->castAs<ReferenceType>()->getPointeeType(); + } + + assert(srcRecordTy->isRecordType() && "source type must be a record type!"); + assert(!cir::MissingFeatures::emitTypeCheck()); + + if (dce->isAlwaysNull()) { + cgm.errorNYI(dce->getSourceRange(), "emitDynamicCastToNull"); + return {}; + } + + auto destCirTy = mlir::cast<cir::PointerType>(convertType(destTy)); + return cgm.getCXXABI().emitDynamicCast(*this, loc, srcRecordTy, destRecordTy, + destCirTy, isRefCast, thisAddr); +} diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp index 59aa257..89e9ec4 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp @@ -500,6 +500,26 @@ private: bool appendBitField(const FieldDecl *field, uint64_t fieldOffset, cir::IntAttr ci, bool allowOverwrite = false); + /// Applies zero-initialization to padding bytes before and within a field. + /// \param layout The record layout containing field offset information. + /// \param fieldNo The field index in the record. + /// \param field The field declaration. + /// \param allowOverwrite Whether to allow overwriting existing values. + /// \param sizeSoFar The current size processed, updated by this function. + /// \param zeroFieldSize Set to true if the field has zero size. + /// \returns true on success, false if padding could not be applied. + bool applyZeroInitPadding(const ASTRecordLayout &layout, unsigned fieldNo, + const FieldDecl &field, bool allowOverwrite, + CharUnits &sizeSoFar, bool &zeroFieldSize); + + /// Applies zero-initialization to trailing padding bytes in a record. + /// \param layout The record layout containing size information. + /// \param allowOverwrite Whether to allow overwriting existing values. + /// \param sizeSoFar The current size processed. + /// \returns true on success, false if padding could not be applied. + bool applyZeroInitPadding(const ASTRecordLayout &layout, bool allowOverwrite, + CharUnits &sizeSoFar); + bool build(InitListExpr *ile, bool allowOverwrite); bool build(const APValue &val, const RecordDecl *rd, bool isPrimaryBase, const CXXRecordDecl *vTableClass, CharUnits baseOffset); @@ -548,6 +568,49 @@ bool ConstRecordBuilder::appendBitField(const FieldDecl *field, allowOverwrite); } +bool ConstRecordBuilder::applyZeroInitPadding( + const ASTRecordLayout &layout, unsigned fieldNo, const FieldDecl &field, + bool allowOverwrite, CharUnits &sizeSoFar, bool &zeroFieldSize) { + uint64_t startBitOffset = layout.getFieldOffset(fieldNo); + CharUnits startOffset = + cgm.getASTContext().toCharUnitsFromBits(startBitOffset); + if (sizeSoFar < startOffset) { + if (!appendBytes(sizeSoFar, computePadding(cgm, startOffset - sizeSoFar), + allowOverwrite)) + return false; + } + + if (!field.isBitField()) { + CharUnits fieldSize = + cgm.getASTContext().getTypeSizeInChars(field.getType()); + sizeSoFar = startOffset + fieldSize; + zeroFieldSize = fieldSize.isZero(); + } else { + const CIRGenRecordLayout &rl = + cgm.getTypes().getCIRGenRecordLayout(field.getParent()); + const CIRGenBitFieldInfo &info = rl.getBitFieldInfo(&field); + uint64_t endBitOffset = startBitOffset + info.size; + sizeSoFar = cgm.getASTContext().toCharUnitsFromBits(endBitOffset); + if (endBitOffset % cgm.getASTContext().getCharWidth() != 0) + sizeSoFar++; + zeroFieldSize = info.size == 0; + } + return true; +} + +bool ConstRecordBuilder::applyZeroInitPadding(const ASTRecordLayout &layout, + bool allowOverwrite, + CharUnits &sizeSoFar) { + CharUnits totalSize = layout.getSize(); + if (sizeSoFar < totalSize) { + if (!appendBytes(sizeSoFar, computePadding(cgm, totalSize - sizeSoFar), + allowOverwrite)) + return false; + } + sizeSoFar = totalSize; + return true; +} + bool ConstRecordBuilder::build(InitListExpr *ile, bool allowOverwrite) { RecordDecl *rd = ile->getType() ->castAs<clang::RecordType>() @@ -562,11 +625,9 @@ bool ConstRecordBuilder::build(InitListExpr *ile, bool allowOverwrite) { if (cxxrd->getNumBases()) return false; - if (cgm.shouldZeroInitPadding()) { - assert(!cir::MissingFeatures::recordZeroInitPadding()); - cgm.errorNYI(rd->getSourceRange(), "zero init padding"); - return false; - } + const bool zeroInitPadding = cgm.shouldZeroInitPadding(); + bool zeroFieldSize = false; + CharUnits sizeSoFar = CharUnits::Zero(); unsigned elementNo = 0; for (auto [index, field] : llvm::enumerate(rd->fields())) { @@ -596,7 +657,10 @@ bool ConstRecordBuilder::build(InitListExpr *ile, bool allowOverwrite) { continue; } - assert(!cir::MissingFeatures::recordZeroInitPadding()); + if (zeroInitPadding && + !applyZeroInitPadding(layout, index, *field, allowOverwrite, sizeSoFar, + zeroFieldSize)) + return false; // When emitting a DesignatedInitUpdateExpr, a nested InitListExpr // represents additional overwriting of our current constant value, and not @@ -641,8 +705,8 @@ bool ConstRecordBuilder::build(InitListExpr *ile, bool allowOverwrite) { } } - assert(!cir::MissingFeatures::recordZeroInitPadding()); - return true; + return !zeroInitPadding || + applyZeroInitPadding(layout, allowOverwrite, sizeSoFar); } namespace { diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp index 5d3496a..637f9ef 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp @@ -1893,7 +1893,34 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *ce) { } return v; } + case CK_IntegralToPointer: { + mlir::Type destCIRTy = cgf.convertType(destTy); + mlir::Value src = Visit(const_cast<Expr *>(subExpr)); + + // Properly resize by casting to an int of the same size as the pointer. + // Clang's IntegralToPointer includes 'bool' as the source, but in CIR + // 'bool' is not an integral type. So check the source type to get the + // correct CIR conversion. + mlir::Type middleTy = cgf.cgm.getDataLayout().getIntPtrType(destCIRTy); + mlir::Value middleVal = builder.createCast( + subExpr->getType()->isBooleanType() ? cir::CastKind::bool_to_int + : cir::CastKind::integral, + src, middleTy); + + if (cgf.cgm.getCodeGenOpts().StrictVTablePointers) { + cgf.cgm.errorNYI(subExpr->getSourceRange(), + "IntegralToPointer: strict vtable pointers"); + return {}; + } + return builder.createIntToPtr(middleVal, destCIRTy); + } + + case CK_Dynamic: { + Address v = cgf.emitPointerWithAlignment(subExpr); + const auto *dce = cast<CXXDynamicCastExpr>(ce); + return cgf.emitDynamicCast(v, dce); + } case CK_ArrayToPointerDecay: return cgf.emitArrayToPointerDecay(subExpr).getPointer(); diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp index 52fb0d7..7a774e0 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp @@ -689,7 +689,9 @@ void CIRGenFunction::emitDestructorBody(FunctionArgList &args) { cgm.errorNYI(dtor->getSourceRange(), "function-try-block destructor"); assert(!cir::MissingFeatures::sanitizers()); - assert(!cir::MissingFeatures::dtorCleanups()); + + // Enter the epilogue cleanups. + RunCleanupsScope dtorEpilogue(*this); // If this is the complete variant, just invoke the base variant; // the epilogue will destruct the virtual bases. But we can't do @@ -708,7 +710,8 @@ void CIRGenFunction::emitDestructorBody(FunctionArgList &args) { assert((body || getTarget().getCXXABI().isMicrosoft()) && "can't emit a dtor without a body for non-Microsoft ABIs"); - assert(!cir::MissingFeatures::dtorCleanups()); + // Enter the cleanup scopes for virtual bases. + enterDtorCleanups(dtor, Dtor_Complete); if (!isTryBody) { QualType thisTy = dtor->getFunctionObjectParameterType(); @@ -723,7 +726,9 @@ void CIRGenFunction::emitDestructorBody(FunctionArgList &args) { case Dtor_Base: assert(body); - assert(!cir::MissingFeatures::dtorCleanups()); + // Enter the cleanup scopes for fields and non-virtual bases. + enterDtorCleanups(dtor, Dtor_Base); + assert(!cir::MissingFeatures::vtableInitialization()); if (isTryBody) { @@ -741,7 +746,8 @@ void CIRGenFunction::emitDestructorBody(FunctionArgList &args) { break; } - assert(!cir::MissingFeatures::dtorCleanups()); + // Jump out through the epilogue cleanups. + dtorEpilogue.forceCleanup(); // Exit the try if applicable. if (isTryBody) diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h index a60efe1..7a606ee 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.h +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h @@ -556,6 +556,33 @@ public: cir::GlobalOp gv, cir::GetGlobalOp gvAddr); + /// Enter the cleanups necessary to complete the given phase of destruction + /// for a destructor. The end result should call destructors on members and + /// base classes in reverse order of their construction. + void enterDtorCleanups(const CXXDestructorDecl *dtor, CXXDtorType type); + + /// Determines whether an EH cleanup is required to destroy a type + /// with the given destruction kind. + /// TODO(cir): could be shared with Clang LLVM codegen + bool needsEHCleanup(QualType::DestructionKind kind) { + switch (kind) { + case QualType::DK_none: + return false; + case QualType::DK_cxx_destructor: + case QualType::DK_objc_weak_lifetime: + case QualType::DK_nontrivial_c_struct: + return getLangOpts().Exceptions; + case QualType::DK_objc_strong_lifetime: + return getLangOpts().Exceptions && + cgm.getCodeGenOpts().ObjCAutoRefCountExceptions; + } + llvm_unreachable("bad destruction kind"); + } + + CleanupKind getCleanupKind(QualType::DestructionKind kind) { + return needsEHCleanup(kind) ? NormalAndEHCleanup : NormalCleanup; + } + /// Set the address of a local variable. void setAddrOfLocalVar(const clang::VarDecl *vd, Address addr) { assert(!localDeclMap.count(vd) && "Decl already exists in LocalDeclMap!"); @@ -1285,6 +1312,8 @@ public: mlir::LogicalResult emitDoStmt(const clang::DoStmt &s); + mlir::Value emitDynamicCast(Address thisAddr, const CXXDynamicCastExpr *dce); + /// Emit an expression as an initializer for an object (variable, field, etc.) /// at the given location. The expression is not necessarily the normal /// initializer for the object, and the address is not necessarily diff --git a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp index 0418174..9e490c6d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp @@ -59,7 +59,11 @@ public: void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy, FunctionArgList ¶ms) override; - + mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf, + const CXXDestructorDecl *dd, + CXXDtorType type, + bool forVirtualBase, + bool delegating) override; void emitCXXConstructors(const clang::CXXConstructorDecl *d) override; void emitCXXDestructors(const clang::CXXDestructorDecl *d) override; void emitCXXStructor(clang::GlobalDecl gd) override; @@ -68,6 +72,8 @@ public: CXXDtorType type, bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy) override; + void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor, + mlir::Value addr) override; void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override; void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override; @@ -116,6 +122,16 @@ public: Address thisAddr, const CXXRecordDecl *classDecl, const CXXRecordDecl *baseClassDecl) override; + // The traditional clang CodeGen emits calls to `__dynamic_cast` directly into + // LLVM in the `emitDynamicCastCall` function. In CIR, `dynamic_cast` + // expressions are lowered to `cir.dyn_cast` ops instead of calls to runtime + // functions. So during CIRGen we don't need the `emitDynamicCastCall` + // function that clang CodeGen has. + mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc, + QualType srcRecordTy, QualType destRecordTy, + cir::PointerType destCIRTy, bool isRefCast, + Address src) override; + /**************************** RTTI Uniqueness ******************************/ protected: /// Returns true if the ABI requires RTTI type_info objects to be unique @@ -1492,11 +1508,8 @@ void CIRGenItaniumCXXABI::emitDestructorCall( CIRGenFunction &cgf, const CXXDestructorDecl *dd, CXXDtorType type, bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy) { GlobalDecl gd(dd, type); - if (needsVTTParameter(gd)) { - cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: VTT"); - } - - mlir::Value vtt = nullptr; + mlir::Value vtt = + getCXXDestructorImplicitParam(cgf, dd, type, forVirtualBase, delegating); ASTContext &astContext = cgm.getASTContext(); QualType vttTy = astContext.getPointerType(astContext.VoidPtrTy); assert(!cir::MissingFeatures::appleKext()); @@ -1507,6 +1520,34 @@ void CIRGenItaniumCXXABI::emitDestructorCall( vttTy, nullptr); } +void CIRGenItaniumCXXABI::registerGlobalDtor(const VarDecl *vd, + cir::FuncOp dtor, + mlir::Value addr) { + if (vd->isNoDestroy(cgm.getASTContext())) + return; + + if (vd->getTLSKind()) { + cgm.errorNYI(vd->getSourceRange(), "registerGlobalDtor: TLS"); + return; + } + + // HLSL doesn't support atexit. + if (cgm.getLangOpts().HLSL) { + cgm.errorNYI(vd->getSourceRange(), "registerGlobalDtor: HLSL"); + return; + } + + // The default behavior is to use atexit. This is handled in lowering + // prepare. Nothing to be done for CIR here. +} + +mlir::Value CIRGenItaniumCXXABI::getCXXDestructorImplicitParam( + CIRGenFunction &cgf, const CXXDestructorDecl *dd, CXXDtorType type, + bool forVirtualBase, bool delegating) { + GlobalDecl gd(dd, type); + return cgf.getVTTParameter(gd, forVirtualBase, delegating); +} + // The idea here is creating a separate block for the throw with an // `UnreachableOp` as the terminator. So, we branch from the current block // to the throw block and create a block for the remaining operations. @@ -1796,3 +1837,143 @@ mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset( } return vbaseOffset; } + +static cir::FuncOp getBadCastFn(CIRGenFunction &cgf) { + // Prototype: void __cxa_bad_cast(); + + // TODO(cir): set the calling convention of the runtime function. + assert(!cir::MissingFeatures::opFuncCallingConv()); + + cir::FuncType fnTy = + cgf.getBuilder().getFuncType({}, cgf.getBuilder().getVoidTy()); + return cgf.cgm.createRuntimeFunction(fnTy, "__cxa_bad_cast"); +} + +// TODO(cir): This could be shared with classic codegen. +static CharUnits computeOffsetHint(ASTContext &astContext, + const CXXRecordDecl *src, + const CXXRecordDecl *dst) { + CXXBasePaths paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, + /*DetectVirtual=*/false); + + // If Dst is not derived from Src we can skip the whole computation below and + // return that Src is not a public base of Dst. Record all inheritance paths. + if (!dst->isDerivedFrom(src, paths)) + return CharUnits::fromQuantity(-2ULL); + + unsigned numPublicPaths = 0; + CharUnits offset; + + // Now walk all possible inheritance paths. + for (const CXXBasePath &path : paths) { + if (path.Access != AS_public) // Ignore non-public inheritance. + continue; + + ++numPublicPaths; + + for (const CXXBasePathElement &pathElement : path) { + // If the path contains a virtual base class we can't give any hint. + // -1: no hint. + if (pathElement.Base->isVirtual()) + return CharUnits::fromQuantity(-1ULL); + + if (numPublicPaths > 1) // Won't use offsets, skip computation. + continue; + + // Accumulate the base class offsets. + const ASTRecordLayout &L = + astContext.getASTRecordLayout(pathElement.Class); + offset += L.getBaseClassOffset( + pathElement.Base->getType()->getAsCXXRecordDecl()); + } + } + + // -2: Src is not a public base of Dst. + if (numPublicPaths == 0) + return CharUnits::fromQuantity(-2ULL); + + // -3: Src is a multiple public base type but never a virtual base type. + if (numPublicPaths > 1) + return CharUnits::fromQuantity(-3ULL); + + // Otherwise, the Src type is a unique public nonvirtual base type of Dst. + // Return the offset of Src from the origin of Dst. + return offset; +} + +static cir::FuncOp getItaniumDynamicCastFn(CIRGenFunction &cgf) { + // Prototype: + // void *__dynamic_cast(const void *sub, + // global_as const abi::__class_type_info *src, + // global_as const abi::__class_type_info *dst, + // std::ptrdiff_t src2dst_offset); + + mlir::Type voidPtrTy = cgf.getBuilder().getVoidPtrTy(); + mlir::Type rttiPtrTy = cgf.getBuilder().getUInt8PtrTy(); + mlir::Type ptrDiffTy = cgf.convertType(cgf.getContext().getPointerDiffType()); + + // TODO(cir): mark the function as nowind willreturn readonly. + assert(!cir::MissingFeatures::opFuncNoUnwind()); + assert(!cir::MissingFeatures::opFuncWillReturn()); + assert(!cir::MissingFeatures::opFuncReadOnly()); + + // TODO(cir): set the calling convention of the runtime function. + assert(!cir::MissingFeatures::opFuncCallingConv()); + + cir::FuncType FTy = cgf.getBuilder().getFuncType( + {voidPtrTy, rttiPtrTy, rttiPtrTy, ptrDiffTy}, voidPtrTy); + return cgf.cgm.createRuntimeFunction(FTy, "__dynamic_cast"); +} + +static cir::DynamicCastInfoAttr emitDynamicCastInfo(CIRGenFunction &cgf, + mlir::Location loc, + QualType srcRecordTy, + QualType destRecordTy) { + auto srcRtti = mlir::cast<cir::GlobalViewAttr>( + cgf.cgm.getAddrOfRTTIDescriptor(loc, srcRecordTy)); + auto destRtti = mlir::cast<cir::GlobalViewAttr>( + cgf.cgm.getAddrOfRTTIDescriptor(loc, destRecordTy)); + + cir::FuncOp runtimeFuncOp = getItaniumDynamicCastFn(cgf); + cir::FuncOp badCastFuncOp = getBadCastFn(cgf); + auto runtimeFuncRef = mlir::FlatSymbolRefAttr::get(runtimeFuncOp); + auto badCastFuncRef = mlir::FlatSymbolRefAttr::get(badCastFuncOp); + + const CXXRecordDecl *srcDecl = srcRecordTy->getAsCXXRecordDecl(); + const CXXRecordDecl *destDecl = destRecordTy->getAsCXXRecordDecl(); + CharUnits offsetHint = computeOffsetHint(cgf.getContext(), srcDecl, destDecl); + + mlir::Type ptrdiffTy = cgf.convertType(cgf.getContext().getPointerDiffType()); + auto offsetHintAttr = cir::IntAttr::get(ptrdiffTy, offsetHint.getQuantity()); + + return cir::DynamicCastInfoAttr::get(srcRtti, destRtti, runtimeFuncRef, + badCastFuncRef, offsetHintAttr); +} + +mlir::Value CIRGenItaniumCXXABI::emitDynamicCast(CIRGenFunction &cgf, + mlir::Location loc, + QualType srcRecordTy, + QualType destRecordTy, + cir::PointerType destCIRTy, + bool isRefCast, Address src) { + bool isCastToVoid = destRecordTy.isNull(); + assert((!isCastToVoid || !isRefCast) && "cannot cast to void reference"); + + if (isCastToVoid) { + cgm.errorNYI(loc, "emitDynamicCastToVoid"); + return {}; + } + + // If the destination is effectively final, the cast succeeds if and only + // if the dynamic type of the pointer is exactly the destination type. + if (destRecordTy->getAsCXXRecordDecl()->isEffectivelyFinal() && + cgf.cgm.getCodeGenOpts().OptimizationLevel > 0) { + cgm.errorNYI(loc, "emitExactDynamicCast"); + return {}; + } + + cir::DynamicCastInfoAttr castInfo = + emitDynamicCastInfo(cgf, loc, srcRecordTy, destRecordTy); + return cgf.getBuilder().createDynCast(loc, src.getPointer(), destCIRTy, + isRefCast, castInfo); +} diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index 910c8a9..fe1ea56 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp @@ -2079,6 +2079,29 @@ CIRGenModule::createCIRBuiltinFunction(mlir::Location loc, StringRef name, return fnOp; } +cir::FuncOp CIRGenModule::createRuntimeFunction(cir::FuncType ty, + StringRef name, mlir::ArrayAttr, + [[maybe_unused]] bool isLocal, + bool assumeConvergent) { + if (assumeConvergent) + errorNYI("createRuntimeFunction: assumeConvergent"); + if (isLocal) + errorNYI("createRuntimeFunction: local"); + + cir::FuncOp entry = getOrCreateCIRFunction(name, ty, GlobalDecl(), + /*forVtable=*/false); + + if (entry) { + // TODO(cir): set the attributes of the function. + assert(!cir::MissingFeatures::setLLVMFunctionFEnvAttributes()); + assert(!cir::MissingFeatures::opFuncCallingConv()); + assert(!cir::MissingFeatures::opGlobalDLLImportExport()); + entry.setDSOLocal(true); + } + + return entry; +} + mlir::SymbolTable::Visibility CIRGenModule::getMLIRVisibility(cir::GlobalOp op) { // MLIR doesn't accept public symbols declarations (only diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h index c6a6681..f627bae 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.h +++ b/clang/lib/CIR/CodeGen/CIRGenModule.h @@ -480,6 +480,10 @@ public: cir::FuncType ty, const clang::FunctionDecl *fd); + cir::FuncOp createRuntimeFunction(cir::FuncType ty, llvm::StringRef name, + mlir::ArrayAttr = {}, bool isLocal = false, + bool assumeConvergent = false); + static constexpr const char *builtinCoroId = "__builtin_coro_id"; /// Given a builtin id for a function like "__builtin_fabsf", return a diff --git a/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp b/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp index a9af753..4cf2237 100644 --- a/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp @@ -87,7 +87,10 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) { if (const auto *section = dyn_cast<ArraySectionExpr>(curVarExpr)) { QualType baseTy = ArraySectionExpr::getBaseOriginalType( section->getBase()->IgnoreParenImpCasts()); - boundTypes.push_back(QualType(baseTy->getPointeeOrArrayElementType(), 0)); + if (auto *at = getContext().getAsArrayType(baseTy)) + boundTypes.push_back(at->getElementType()); + else + boundTypes.push_back(baseTy->getPointeeType()); } else { boundTypes.push_back(curVarExpr->getType()); } diff --git a/clang/lib/CIR/CodeGen/CIRGenVTables.cpp b/clang/lib/CIR/CodeGen/CIRGenVTables.cpp index 94d856b..84f5977 100644 --- a/clang/lib/CIR/CodeGen/CIRGenVTables.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenVTables.cpp @@ -327,9 +327,40 @@ cir::GlobalLinkageKind CIRGenModule::getVTableLinkage(const CXXRecordDecl *rd) { llvm_unreachable("Should not have been asked to emit this"); } } + // -fapple-kext mode does not support weak linkage, so we must use + // internal linkage. + if (astContext.getLangOpts().AppleKext) + return cir::GlobalLinkageKind::InternalLinkage; + + auto discardableODRLinkage = cir::GlobalLinkageKind::LinkOnceODRLinkage; + auto nonDiscardableODRLinkage = cir::GlobalLinkageKind::WeakODRLinkage; + if (rd->hasAttr<DLLExportAttr>()) { + // Cannot discard exported vtables. + discardableODRLinkage = nonDiscardableODRLinkage; + } else if (rd->hasAttr<DLLImportAttr>()) { + // Imported vtables are available externally. + discardableODRLinkage = cir::GlobalLinkageKind::AvailableExternallyLinkage; + nonDiscardableODRLinkage = + cir::GlobalLinkageKind::AvailableExternallyLinkage; + } + + switch (rd->getTemplateSpecializationKind()) { + case TSK_Undeclared: + case TSK_ExplicitSpecialization: + case TSK_ImplicitInstantiation: + return discardableODRLinkage; + + case TSK_ExplicitInstantiationDeclaration: { + errorNYI(rd->getSourceRange(), + "getVTableLinkage: explicit instantiation declaration"); + return cir::GlobalLinkageKind::ExternalLinkage; + } + + case TSK_ExplicitInstantiationDefinition: + return nonDiscardableODRLinkage; + } - errorNYI(rd->getSourceRange(), "getVTableLinkage: no key function"); - return cir::GlobalLinkageKind::ExternalLinkage; + llvm_unreachable("Invalid TemplateSpecializationKind!"); } cir::GlobalOp CIRGenVTables::getAddrOfVTT(const CXXRecordDecl *rd) { diff --git a/clang/lib/CIR/CodeGen/EHScopeStack.h b/clang/lib/CIR/CodeGen/EHScopeStack.h index 66c1f76..67a72f5 100644 --- a/clang/lib/CIR/CodeGen/EHScopeStack.h +++ b/clang/lib/CIR/CodeGen/EHScopeStack.h @@ -108,9 +108,6 @@ public: /// // \param flags cleanup kind. virtual void emit(CIRGenFunction &cgf) = 0; - - // This is a placeholder until EHScope is implemented. - virtual size_t getSize() const = 0; }; private: diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp index 2eeef81..706e54f 100644 --- a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp +++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp @@ -41,6 +41,16 @@ static SmallString<128> getTransformedFileName(mlir::ModuleOp mlirModule) { return fileName; } +/// Return the FuncOp called by `callOp`. +static cir::FuncOp getCalledFunction(cir::CallOp callOp) { + mlir::SymbolRefAttr sym = llvm::dyn_cast_if_present<mlir::SymbolRefAttr>( + callOp.getCallableForCallee()); + if (!sym) + return nullptr; + return dyn_cast_or_null<cir::FuncOp>( + mlir::SymbolTable::lookupNearestSymbolFrom(callOp, sym)); +} + namespace { struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { LoweringPreparePass() = default; @@ -61,11 +71,20 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { /// Build a module init function that calls all the dynamic initializers. void buildCXXGlobalInitFunc(); + /// Materialize global ctor/dtor list + void buildGlobalCtorDtorList(); + cir::FuncOp buildRuntimeFunction( mlir::OpBuilder &builder, llvm::StringRef name, mlir::Location loc, cir::FuncType type, cir::GlobalLinkageKind linkage = cir::GlobalLinkageKind::ExternalLinkage); + cir::GlobalOp buildRuntimeVariable( + mlir::OpBuilder &builder, llvm::StringRef name, mlir::Location loc, + mlir::Type type, + cir::GlobalLinkageKind linkage = cir::GlobalLinkageKind::ExternalLinkage, + cir::VisibilityKind visibility = cir::VisibilityKind::Default); + /// /// AST related /// ----------- @@ -79,11 +98,33 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { llvm::StringMap<uint32_t> dynamicInitializerNames; llvm::SmallVector<cir::FuncOp> dynamicInitializers; + /// List of ctors and their priorities to be called before main() + llvm::SmallVector<std::pair<std::string, uint32_t>, 4> globalCtorList; + void setASTContext(clang::ASTContext *c) { astCtx = c; } }; } // namespace +cir::GlobalOp LoweringPreparePass::buildRuntimeVariable( + mlir::OpBuilder &builder, llvm::StringRef name, mlir::Location loc, + mlir::Type type, cir::GlobalLinkageKind linkage, + cir::VisibilityKind visibility) { + cir::GlobalOp g = dyn_cast_or_null<cir::GlobalOp>( + mlir::SymbolTable::lookupNearestSymbolFrom( + mlirModule, mlir::StringAttr::get(mlirModule->getContext(), name))); + if (!g) { + g = cir::GlobalOp::create(builder, loc, name, type); + g.setLinkageAttr( + cir::GlobalLinkageKindAttr::get(builder.getContext(), linkage)); + mlir::SymbolTable::setSymbolVisibility( + g, mlir::SymbolTable::Visibility::Private); + g.setGlobalVisibilityAttr( + cir::VisibilityAttr::get(builder.getContext(), visibility)); + } + return g; +} + cir::FuncOp LoweringPreparePass::buildRuntimeFunction( mlir::OpBuilder &builder, llvm::StringRef name, mlir::Location loc, cir::FuncType type, cir::GlobalLinkageKind linkage) { @@ -634,7 +675,8 @@ LoweringPreparePass::buildCXXGlobalVarDeclInitFunc(cir::GlobalOp op) { // Create a variable initialization function. CIRBaseBuilderTy builder(getContext()); builder.setInsertionPointAfter(op); - auto fnType = cir::FuncType::get({}, builder.getVoidTy()); + cir::VoidType voidTy = builder.getVoidTy(); + auto fnType = cir::FuncType::get({}, voidTy); FuncOp f = buildRuntimeFunction(builder, fnName, op.getLoc(), fnType, cir::GlobalLinkageKind::InternalLinkage); @@ -649,8 +691,57 @@ LoweringPreparePass::buildCXXGlobalVarDeclInitFunc(cir::GlobalOp op) { // Register the destructor call with __cxa_atexit mlir::Region &dtorRegion = op.getDtorRegion(); if (!dtorRegion.empty()) { - assert(!cir::MissingFeatures::opGlobalDtorLowering()); - llvm_unreachable("dtor region lowering is NYI"); + assert(!cir::MissingFeatures::astVarDeclInterface()); + assert(!cir::MissingFeatures::opGlobalThreadLocal()); + // Create a variable that binds the atexit to this shared object. + builder.setInsertionPointToStart(&mlirModule.getBodyRegion().front()); + cir::GlobalOp handle = buildRuntimeVariable( + builder, "__dso_handle", op.getLoc(), builder.getI8Type(), + cir::GlobalLinkageKind::ExternalLinkage, cir::VisibilityKind::Hidden); + + // Look for the destructor call in dtorBlock + mlir::Block &dtorBlock = dtorRegion.front(); + cir::CallOp dtorCall; + for (auto op : reverse(dtorBlock.getOps<cir::CallOp>())) { + dtorCall = op; + break; + } + assert(dtorCall && "Expected a dtor call"); + cir::FuncOp dtorFunc = getCalledFunction(dtorCall); + assert(dtorFunc && "Expected a dtor call"); + + // Create a runtime helper function: + // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d); + auto voidPtrTy = cir::PointerType::get(voidTy); + auto voidFnTy = cir::FuncType::get({voidPtrTy}, voidTy); + auto voidFnPtrTy = cir::PointerType::get(voidFnTy); + auto handlePtrTy = cir::PointerType::get(handle.getSymType()); + auto fnAtExitType = + cir::FuncType::get({voidFnPtrTy, voidPtrTy, handlePtrTy}, voidTy); + const char *nameAtExit = "__cxa_atexit"; + cir::FuncOp fnAtExit = + buildRuntimeFunction(builder, nameAtExit, op.getLoc(), fnAtExitType); + + // Replace the dtor call with a call to __cxa_atexit(&dtor, &var, + // &__dso_handle) + builder.setInsertionPointAfter(dtorCall); + mlir::Value args[3]; + auto dtorPtrTy = cir::PointerType::get(dtorFunc.getFunctionType()); + // dtorPtrTy + args[0] = cir::GetGlobalOp::create(builder, dtorCall.getLoc(), dtorPtrTy, + dtorFunc.getSymName()); + args[0] = cir::CastOp::create(builder, dtorCall.getLoc(), voidFnPtrTy, + cir::CastKind::bitcast, args[0]); + args[1] = + cir::CastOp::create(builder, dtorCall.getLoc(), voidPtrTy, + cir::CastKind::bitcast, dtorCall.getArgOperand(0)); + args[2] = cir::GetGlobalOp::create(builder, handle.getLoc(), handlePtrTy, + handle.getSymName()); + builder.createCallOp(dtorCall.getLoc(), fnAtExit, args); + dtorCall->erase(); + entryBB->getOperations().splice(entryBB->end(), dtorBlock.getOperations(), + dtorBlock.begin(), + std::prev(dtorBlock.end())); } // Replace cir.yield with cir.return @@ -660,11 +751,12 @@ LoweringPreparePass::buildCXXGlobalVarDeclInitFunc(cir::GlobalOp op) { mlir::Block &block = op.getCtorRegion().front(); yieldOp = &block.getOperations().back(); } else { - assert(!cir::MissingFeatures::opGlobalDtorLowering()); - llvm_unreachable("dtor region lowering is NYI"); + assert(!dtorRegion.empty()); + mlir::Block &block = dtorRegion.front(); + yieldOp = &block.getOperations().back(); } - assert(isa<YieldOp>(*yieldOp)); + assert(isa<cir::YieldOp>(*yieldOp)); cir::ReturnOp::create(builder, yieldOp->getLoc()); return f; } @@ -689,11 +781,39 @@ void LoweringPreparePass::lowerGlobalOp(GlobalOp op) { assert(!cir::MissingFeatures::opGlobalAnnotations()); } +template <typename AttributeTy> +static llvm::SmallVector<mlir::Attribute> +prepareCtorDtorAttrList(mlir::MLIRContext *context, + llvm::ArrayRef<std::pair<std::string, uint32_t>> list) { + llvm::SmallVector<mlir::Attribute> attrs; + for (const auto &[name, priority] : list) + attrs.push_back(AttributeTy::get(context, name, priority)); + return attrs; +} + +void LoweringPreparePass::buildGlobalCtorDtorList() { + if (!globalCtorList.empty()) { + llvm::SmallVector<mlir::Attribute> globalCtors = + prepareCtorDtorAttrList<cir::GlobalCtorAttr>(&getContext(), + globalCtorList); + + mlirModule->setAttr(cir::CIRDialect::getGlobalCtorsAttrName(), + mlir::ArrayAttr::get(&getContext(), globalCtors)); + } + + // We will eventual need to populate a global_dtor list, but that's not + // needed for globals with destructors. It will only be needed for functions + // that are marked as global destructors with an attribute. + assert(!cir::MissingFeatures::opGlobalDtorList()); +} + void LoweringPreparePass::buildCXXGlobalInitFunc() { if (dynamicInitializers.empty()) return; - assert(!cir::MissingFeatures::opGlobalCtorList()); + // TODO: handle globals with a user-specified initialzation priority. + // TODO: handle default priority more nicely. + assert(!cir::MissingFeatures::opGlobalCtorPriority()); SmallString<256> fnName; // Include the filename in the symbol name. Including "sub_" matches gcc @@ -722,6 +842,10 @@ void LoweringPreparePass::buildCXXGlobalInitFunc() { builder.setInsertionPointToStart(f.addEntryBlock()); for (cir::FuncOp &f : dynamicInitializers) builder.createCallOp(f.getLoc(), f, {}); + // Add the global init function (not the individual ctor functions) to the + // global ctor list. + globalCtorList.emplace_back(fnName, + cir::GlobalCtorAttr::getDefaultPriority()); cir::ReturnOp::create(builder, f.getLoc()); } @@ -852,6 +976,7 @@ void LoweringPreparePass::runOnOperation() { runOnOp(o); buildCXXGlobalInitFunc(); + buildGlobalCtorDtorList(); } std::unique_ptr<Pass> mlir::createLoweringPreparePass() { diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index e9649af..a1ecfc7 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -1771,9 +1771,13 @@ mlir::LogicalResult CIRToLLVMGlobalOpLowering::matchAndRewrite( } // Rewrite op. - rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>( + auto newOp = rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>( op, llvmType, isConst, linkage, symbol, init.value_or(mlir::Attribute()), alignment, addrSpace, isDsoLocal, isThreadLocal, comdatAttr, attributes); + newOp.setVisibility_Attr(mlir::LLVM::VisibilityAttr::get( + getContext(), lowerCIRVisibilityToLLVMVisibility( + op.getGlobalVisibilityAttr().getValue()))); + return mlir::success(); } @@ -2413,6 +2417,73 @@ static void prepareTypeConverter(mlir::LLVMTypeConverter &converter, }); } +static void buildCtorDtorList( + mlir::ModuleOp module, StringRef globalXtorName, StringRef llvmXtorName, + llvm::function_ref<std::pair<StringRef, int>(mlir::Attribute)> createXtor) { + llvm::SmallVector<std::pair<StringRef, int>> globalXtors; + for (const mlir::NamedAttribute namedAttr : module->getAttrs()) { + if (namedAttr.getName() == globalXtorName) { + for (auto attr : mlir::cast<mlir::ArrayAttr>(namedAttr.getValue())) + globalXtors.emplace_back(createXtor(attr)); + break; + } + } + + if (globalXtors.empty()) + return; + + mlir::OpBuilder builder(module.getContext()); + builder.setInsertionPointToEnd(&module.getBodyRegion().back()); + + // Create a global array llvm.global_ctors with element type of + // struct { i32, ptr, ptr } + auto ctorPFTy = mlir::LLVM::LLVMPointerType::get(builder.getContext()); + llvm::SmallVector<mlir::Type> ctorStructFields; + ctorStructFields.push_back(builder.getI32Type()); + ctorStructFields.push_back(ctorPFTy); + ctorStructFields.push_back(ctorPFTy); + + auto ctorStructTy = mlir::LLVM::LLVMStructType::getLiteral( + builder.getContext(), ctorStructFields); + auto ctorStructArrayTy = + mlir::LLVM::LLVMArrayType::get(ctorStructTy, globalXtors.size()); + + mlir::Location loc = module.getLoc(); + auto newGlobalOp = mlir::LLVM::GlobalOp::create( + builder, loc, ctorStructArrayTy, /*constant=*/false, + mlir::LLVM::Linkage::Appending, llvmXtorName, mlir::Attribute()); + + builder.createBlock(&newGlobalOp.getRegion()); + builder.setInsertionPointToEnd(newGlobalOp.getInitializerBlock()); + + mlir::Value result = + mlir::LLVM::UndefOp::create(builder, loc, ctorStructArrayTy); + + for (auto [index, fn] : llvm::enumerate(globalXtors)) { + mlir::Value structInit = + mlir::LLVM::UndefOp::create(builder, loc, ctorStructTy); + mlir::Value initPriority = mlir::LLVM::ConstantOp::create( + builder, loc, ctorStructFields[0], fn.second); + mlir::Value initFuncAddr = mlir::LLVM::AddressOfOp::create( + builder, loc, ctorStructFields[1], fn.first); + mlir::Value initAssociate = + mlir::LLVM::ZeroOp::create(builder, loc, ctorStructFields[2]); + // Literal zero makes the InsertValueOp::create ambiguous. + llvm::SmallVector<int64_t> zero{0}; + structInit = mlir::LLVM::InsertValueOp::create(builder, loc, structInit, + initPriority, zero); + structInit = mlir::LLVM::InsertValueOp::create(builder, loc, structInit, + initFuncAddr, 1); + // TODO: handle associated data for initializers. + structInit = mlir::LLVM::InsertValueOp::create(builder, loc, structInit, + initAssociate, 2); + result = mlir::LLVM::InsertValueOp::create(builder, loc, result, structInit, + index); + } + + builder.create<mlir::LLVM::ReturnOp>(loc, result); +} + // The applyPartialConversion function traverses blocks in the dominance order, // so it does not lower and operations that are not reachachable from the // operations passed in as arguments. Since we do need to lower such code in @@ -2519,6 +2590,15 @@ void ConvertCIRToLLVMPass::runOnOperation() { if (failed(applyPartialConversion(ops, target, std::move(patterns)))) signalPassFailure(); + + // Emit the llvm.global_ctors array. + buildCtorDtorList(module, cir::CIRDialect::getGlobalCtorsAttrName(), + "llvm.global_ctors", [](mlir::Attribute attr) { + auto ctorAttr = mlir::cast<cir::GlobalCtorAttr>(attr); + return std::make_pair(ctorAttr.getName(), + ctorAttr.getPriority()); + }); + assert(!cir::MissingFeatures::opGlobalDtorList()); } mlir::LogicalResult CIRToLLVMBrOpLowering::matchAndRewrite( diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp index 64f1917..2d95982 100644 --- a/clang/lib/CodeGen/BackendUtil.cpp +++ b/clang/lib/CodeGen/BackendUtil.cpp @@ -60,11 +60,13 @@ #include "llvm/TargetParser/Triple.h" #include "llvm/Transforms/HipStdPar/HipStdPar.h" #include "llvm/Transforms/IPO/EmbedBitcodePass.h" +#include "llvm/Transforms/IPO/InferFunctionAttrs.h" #include "llvm/Transforms/IPO/LowerTypeTests.h" #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h" #include "llvm/Transforms/InstCombine/InstCombine.h" #include "llvm/Transforms/Instrumentation/AddressSanitizer.h" #include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h" +#include "llvm/Transforms/Instrumentation/AllocToken.h" #include "llvm/Transforms/Instrumentation/BoundsChecking.h" #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h" #include "llvm/Transforms/Instrumentation/GCOVProfiler.h" @@ -232,6 +234,14 @@ public: }; } // namespace +static AllocTokenOptions getAllocTokenOptions(const CodeGenOptions &CGOpts) { + AllocTokenOptions Opts; + Opts.MaxTokens = CGOpts.AllocTokenMax; + Opts.Extended = CGOpts.SanitizeAllocTokenExtended; + Opts.FastABI = CGOpts.SanitizeAllocTokenFastABI; + return Opts; +} + static SanitizerCoverageOptions getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts) { SanitizerCoverageOptions Opts; @@ -789,6 +799,16 @@ static void addSanitizers(const Triple &TargetTriple, MPM.addPass(DataFlowSanitizerPass(LangOpts.NoSanitizeFiles, PB.getVirtualFileSystemPtr())); } + + if (LangOpts.Sanitize.has(SanitizerKind::AllocToken)) { + if (Level == OptimizationLevel::O0) { + // The default pass builder only infers libcall function attrs when + // optimizing, so we insert it here because we need it for accurate + // memory allocation function detection. + MPM.addPass(InferFunctionAttrsPass()); + } + MPM.addPass(AllocTokenPass(getAllocTokenOptions(CodeGenOpts))); + } }; if (ClSanitizeOnOptimizerEarlyEP) { PB.registerOptimizerEarlyEPCallback( diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index a931ce4..c5371e4 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -3018,8 +3018,7 @@ void CodeGenModule::ConstructAttributeList(StringRef Name, ArgNo = 0; if (AddedPotentialArgAccess && MemAttrForPtrArgs) { - llvm::FunctionType *FunctionType = FunctionType = - getTypes().GetFunctionType(FI); + llvm::FunctionType *FunctionType = getTypes().GetFunctionType(FI); for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(), E = FI.arg_end(); I != E; ++I, ++ArgNo) { diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index fee6bc0..9fe9a13 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -787,7 +787,8 @@ void CGDebugInfo::CreateCompileUnit() { // Create new compile unit. TheCU = DBuilder.createCompileUnit( - LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer : "", + llvm::DISourceLanguageName(LangTag), CUFile, + CGOpts.EmitVersionIdentMetadata ? Producer : "", CGOpts.OptimizationLevel != 0 || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO, CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind, @@ -899,10 +900,13 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) { assert((BT->getKind() != BuiltinType::SveCount || Info.NumVectors == 1) && "Unsupported number of vectors for svcount_t"); - // Debuggers can't extract 1bit from a vector, so will display a - // bitpattern for predicates instead. unsigned NumElems = Info.EC.getKnownMinValue() * Info.NumVectors; - if (Info.ElementType == CGM.getContext().BoolTy) { + llvm::Metadata *BitStride = nullptr; + if (BT->getKind() == BuiltinType::SveBool) { + Info.ElementType = CGM.getContext().UnsignedCharTy; + BitStride = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned( + llvm::Type::getInt64Ty(CGM.getLLVMContext()), 1)); + } else if (BT->getKind() == BuiltinType::SveCount) { NumElems /= 8; Info.ElementType = CGM.getContext().UnsignedCharTy; } @@ -928,7 +932,7 @@ llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) { getOrCreateType(Info.ElementType, TheCU->getFile()); auto Align = getTypeAlignIfRequired(BT, CGM.getContext()); return DBuilder.createVectorType(/*Size*/ 0, Align, ElemTy, - SubscriptArray); + SubscriptArray, BitStride); } // It doesn't make sense to generate debug info for PowerPC MMA vector types. // So we return a safe type here to avoid generating an error. @@ -1232,7 +1236,7 @@ llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty, /// \return whether a C++ mangling exists for the type defined by TD. static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) { - switch (TheCU->getSourceLanguage()) { + switch (TheCU->getSourceLanguage().getUnversionedName()) { case llvm::dwarf::DW_LANG_C_plus_plus: case llvm::dwarf::DW_LANG_C_plus_plus_11: case llvm::dwarf::DW_LANG_C_plus_plus_14: @@ -3211,8 +3215,8 @@ llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, if (!ID) return nullptr; - auto RuntimeLang = - static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage()); + auto RuntimeLang = static_cast<llvm::dwarf::SourceLanguage>( + TheCU->getSourceLanguage().getUnversionedName()); // Return a forward declaration if this type was imported from a clang module, // and this is not the compile unit with the implementation of the type (which @@ -3348,7 +3352,8 @@ llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty, ObjCInterfaceDecl *ID = Ty->getDecl(); llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation()); unsigned Line = getLineNumber(ID->getLocation()); - unsigned RuntimeLang = TheCU->getSourceLanguage(); + + unsigned RuntimeLang = TheCU->getSourceLanguage().getUnversionedName(); // Bit size, align and offset of the type. uint64_t Size = CGM.getContext().getTypeSize(Ty); diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index 9f30287..e8255b0 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -30,6 +30,7 @@ #include "clang/AST/Attr.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/NSAPI.h" +#include "clang/AST/ParentMapContext.h" #include "clang/AST/StmtVisitor.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/CodeGenOptions.h" @@ -1272,6 +1273,196 @@ void CodeGenFunction::EmitBoundsCheckImpl(const Expr *E, llvm::Value *Bound, EmitCheck(std::make_pair(Check, CheckKind), CheckHandler, StaticData, Index); } +static bool +typeContainsPointer(QualType T, + llvm::SmallPtrSet<const RecordDecl *, 4> &VisitedRD, + bool &IncompleteType) { + QualType CanonicalType = T.getCanonicalType(); + if (CanonicalType->isPointerType()) + return true; // base case + + // Look through typedef chain to check for special types. + for (QualType CurrentT = T; const auto *TT = CurrentT->getAs<TypedefType>(); + CurrentT = TT->getDecl()->getUnderlyingType()) { + const IdentifierInfo *II = TT->getDecl()->getIdentifier(); + // Special Case: Syntactically uintptr_t is not a pointer; semantically, + // however, very likely used as such. Therefore, classify uintptr_t as a + // pointer, too. + if (II && II->isStr("uintptr_t")) + return true; + } + + // The type is an array; check the element type. + if (const ArrayType *AT = dyn_cast<ArrayType>(CanonicalType)) + return typeContainsPointer(AT->getElementType(), VisitedRD, IncompleteType); + // The type is a struct, class, or union. + if (const RecordDecl *RD = CanonicalType->getAsRecordDecl()) { + if (!RD->isCompleteDefinition()) { + IncompleteType = true; + return false; + } + if (!VisitedRD.insert(RD).second) + return false; // already visited + // Check all fields. + for (const FieldDecl *Field : RD->fields()) { + if (typeContainsPointer(Field->getType(), VisitedRD, IncompleteType)) + return true; + } + // For C++ classes, also check base classes. + if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) { + // Polymorphic types require a vptr. + if (CXXRD->isDynamicClass()) + return true; + for (const CXXBaseSpecifier &Base : CXXRD->bases()) { + if (typeContainsPointer(Base.getType(), VisitedRD, IncompleteType)) + return true; + } + } + } + return false; +} + +void CodeGenFunction::EmitAllocToken(llvm::CallBase *CB, QualType AllocType) { + assert(SanOpts.has(SanitizerKind::AllocToken) && + "Only needed with -fsanitize=alloc-token"); + + llvm::MDBuilder MDB(getLLVMContext()); + + // Get unique type name. + PrintingPolicy Policy(CGM.getContext().getLangOpts()); + Policy.SuppressTagKeyword = true; + Policy.FullyQualifiedName = true; + SmallString<64> TypeName; + llvm::raw_svector_ostream TypeNameOS(TypeName); + AllocType.getCanonicalType().print(TypeNameOS, Policy); + auto *TypeNameMD = MDB.createString(TypeNameOS.str()); + + // Check if QualType contains a pointer. Implements a simple DFS to + // recursively check if a type contains a pointer type. + llvm::SmallPtrSet<const RecordDecl *, 4> VisitedRD; + bool IncompleteType = false; + const bool ContainsPtr = + typeContainsPointer(AllocType, VisitedRD, IncompleteType); + if (!ContainsPtr && IncompleteType) + return; + auto *ContainsPtrC = Builder.getInt1(ContainsPtr); + auto *ContainsPtrMD = MDB.createConstant(ContainsPtrC); + + // Format: !{<type-name>, <contains-pointer>} + auto *MDN = + llvm::MDNode::get(CGM.getLLVMContext(), {TypeNameMD, ContainsPtrMD}); + CB->setMetadata(llvm::LLVMContext::MD_alloc_token, MDN); +} + +namespace { +/// Infer type from a simple sizeof expression. +QualType inferTypeFromSizeofExpr(const Expr *E) { + const Expr *Arg = E->IgnoreParenImpCasts(); + if (const auto *UET = dyn_cast<UnaryExprOrTypeTraitExpr>(Arg)) { + if (UET->getKind() == UETT_SizeOf) { + if (UET->isArgumentType()) + return UET->getArgumentTypeInfo()->getType(); + else + return UET->getArgumentExpr()->getType(); + } + } + return QualType(); +} + +/// Infer type from an arithmetic expression involving a sizeof. For example: +/// +/// malloc(sizeof(MyType) + padding); // infers 'MyType' +/// malloc(sizeof(MyType) * 32); // infers 'MyType' +/// malloc(32 * sizeof(MyType)); // infers 'MyType' +/// malloc(sizeof(MyType) << 1); // infers 'MyType' +/// ... +/// +/// More complex arithmetic expressions are supported, but are a heuristic, e.g. +/// when considering allocations for structs with flexible array members: +/// +/// malloc(sizeof(HasFlexArray) + sizeof(int) * 32); // infers 'HasFlexArray' +/// +QualType inferPossibleTypeFromArithSizeofExpr(const Expr *E) { + const Expr *Arg = E->IgnoreParenImpCasts(); + // The argument is a lone sizeof expression. + if (QualType T = inferTypeFromSizeofExpr(Arg); !T.isNull()) + return T; + if (const auto *BO = dyn_cast<BinaryOperator>(Arg)) { + // Argument is an arithmetic expression. Cover common arithmetic patterns + // involving sizeof. + switch (BO->getOpcode()) { + case BO_Add: + case BO_Div: + case BO_Mul: + case BO_Shl: + case BO_Shr: + case BO_Sub: + if (QualType T = inferPossibleTypeFromArithSizeofExpr(BO->getLHS()); + !T.isNull()) + return T; + if (QualType T = inferPossibleTypeFromArithSizeofExpr(BO->getRHS()); + !T.isNull()) + return T; + break; + default: + break; + } + } + return QualType(); +} + +/// If the expression E is a reference to a variable, infer the type from a +/// variable's initializer if it contains a sizeof. Beware, this is a heuristic +/// and ignores if a variable is later reassigned. For example: +/// +/// size_t my_size = sizeof(MyType); +/// void *x = malloc(my_size); // infers 'MyType' +/// +QualType inferPossibleTypeFromVarInitSizeofExpr(const Expr *E) { + const Expr *Arg = E->IgnoreParenImpCasts(); + if (const auto *DRE = dyn_cast<DeclRefExpr>(Arg)) { + if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) { + if (const Expr *Init = VD->getInit()) + return inferPossibleTypeFromArithSizeofExpr(Init); + } + } + return QualType(); +} + +/// Deduces the allocated type by checking if the allocation call's result +/// is immediately used in a cast expression. For example: +/// +/// MyType *x = (MyType *)malloc(4096); // infers 'MyType' +/// +QualType inferPossibleTypeFromCastExpr(const CallExpr *CallE, + const CastExpr *CastE) { + if (!CastE) + return QualType(); + QualType PtrType = CastE->getType(); + if (PtrType->isPointerType()) + return PtrType->getPointeeType(); + return QualType(); +} +} // end anonymous namespace + +void CodeGenFunction::EmitAllocToken(llvm::CallBase *CB, const CallExpr *E) { + QualType AllocType; + // First check arguments. + for (const Expr *Arg : E->arguments()) { + AllocType = inferPossibleTypeFromArithSizeofExpr(Arg); + if (AllocType.isNull()) + AllocType = inferPossibleTypeFromVarInitSizeofExpr(Arg); + if (!AllocType.isNull()) + break; + } + // Then check later casts. + if (AllocType.isNull()) + AllocType = inferPossibleTypeFromCastExpr(E, CurCast); + // Emit if we were able to infer the type. + if (!AllocType.isNull()) + EmitAllocToken(CB, AllocType); +} + CodeGenFunction::ComplexPairTy CodeGenFunction:: EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, bool isInc, bool isPre) { @@ -5642,6 +5833,9 @@ LValue CodeGenFunction::EmitConditionalOperatorLValue( /// are permitted with aggregate result, including noop aggregate casts, and /// cast from scalar to union. LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { + auto RestoreCurCast = + llvm::make_scope_exit([this, Prev = CurCast] { CurCast = Prev; }); + CurCast = E; switch (E->getCastKind()) { case CK_ToVoid: case CK_BitCast: @@ -6587,16 +6781,24 @@ RValue CodeGenFunction::EmitCall(QualType CalleeType, RValue Call = EmitCall(FnInfo, Callee, ReturnValue, Args, &LocalCallOrInvoke, E == MustTailCall, E->getExprLoc()); - // Generate function declaration DISuprogram in order to be used - // in debug info about call sites. - if (CGDebugInfo *DI = getDebugInfo()) { - if (auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) { + if (auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) { + // Generate function declaration DISuprogram in order to be used + // in debug info about call sites. + if (CGDebugInfo *DI = getDebugInfo()) { FunctionArgList Args; QualType ResTy = BuildFunctionArgList(CalleeDecl, Args); DI->EmitFuncDeclForCallSite(LocalCallOrInvoke, DI->getFunctionType(CalleeDecl, ResTy, Args), CalleeDecl); } + if (CalleeDecl->hasAttr<RestrictAttr>() || + CalleeDecl->hasAttr<AllocSizeAttr>()) { + // Function has 'malloc' (aka. 'restrict') or 'alloc_size' attribute. + if (SanOpts.has(SanitizerKind::AllocToken)) { + // Set !alloc_token metadata. + EmitAllocToken(LocalCallOrInvoke, E); + } + } } if (CallOrInvoke) *CallOrInvoke = LocalCallOrInvoke; diff --git a/clang/lib/CodeGen/CGExprCXX.cpp b/clang/lib/CodeGen/CGExprCXX.cpp index c52526c..31ac266 100644 --- a/clang/lib/CodeGen/CGExprCXX.cpp +++ b/clang/lib/CodeGen/CGExprCXX.cpp @@ -1371,8 +1371,16 @@ RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name)) if (auto *FD = dyn_cast<FunctionDecl>(Decl)) - if (Ctx.hasSameType(FD->getType(), QualType(Type, 0))) - return EmitNewDeleteCall(*this, FD, Type, Args); + if (Ctx.hasSameType(FD->getType(), QualType(Type, 0))) { + RValue RV = EmitNewDeleteCall(*this, FD, Type, Args); + if (auto *CB = dyn_cast_if_present<llvm::CallBase>(RV.getScalarVal())) { + if (SanOpts.has(SanitizerKind::AllocToken)) { + // Set !alloc_token metadata. + EmitAllocToken(CB, TheCall); + } + } + return RV; + } llvm_unreachable("predeclared global operator new/delete is missing"); } @@ -1655,11 +1663,16 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) { RValue RV = EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs); - // Set !heapallocsite metadata on the call to operator new. - if (getDebugInfo()) - if (auto *newCall = dyn_cast<llvm::CallBase>(RV.getScalarVal())) - getDebugInfo()->addHeapAllocSiteMetadata(newCall, allocType, - E->getExprLoc()); + if (auto *newCall = dyn_cast<llvm::CallBase>(RV.getScalarVal())) { + if (auto *CGDI = getDebugInfo()) { + // Set !heapallocsite metadata on the call to operator new. + CGDI->addHeapAllocSiteMetadata(newCall, allocType, E->getExprLoc()); + } + if (SanOpts.has(SanitizerKind::AllocToken)) { + // Set !alloc_token metadata. + EmitAllocToken(newCall, allocType); + } + } // If this was a call to a global replaceable allocation function that does // not take an alignment argument, the allocator is known to produce diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp index 06d9d81..715160d 100644 --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -33,6 +33,7 @@ #include "clang/Basic/DiagnosticTrap.h" #include "clang/Basic/TargetInfo.h" #include "llvm/ADT/APFixedPoint.h" +#include "llvm/ADT/ScopeExit.h" #include "llvm/IR/Argument.h" #include "llvm/IR/CFG.h" #include "llvm/IR/Constants.h" @@ -2434,6 +2435,10 @@ static Value *EmitHLSLElementwiseCast(CodeGenFunction &CGF, LValue SrcVal, // have to handle a more broad range of conversions than explicit casts, as they // handle things like function to ptr-to-function decay etc. Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { + auto RestoreCurCast = + llvm::make_scope_exit([this, Prev = CGF.CurCast] { CGF.CurCast = Prev; }); + CGF.CurCast = CE; + Expr *E = CE->getSubExpr(); QualType DestTy = CE->getType(); CastKind Kind = CE->getCastKind(); diff --git a/clang/lib/CodeGen/CGHLSLBuiltins.cpp b/clang/lib/CodeGen/CGHLSLBuiltins.cpp index 6c0fc8d..4f2f5a76 100644 --- a/clang/lib/CodeGen/CGHLSLBuiltins.cpp +++ b/clang/lib/CodeGen/CGHLSLBuiltins.cpp @@ -352,6 +352,19 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID, SmallVector<Value *> Args{OrderID, SpaceOp, RangeOp, IndexOp, Name}; return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args); } + case Builtin::BI__builtin_hlsl_resource_counterhandlefromimplicitbinding: { + Value *MainHandle = EmitScalarExpr(E->getArg(0)); + if (!CGM.getTriple().isSPIRV()) + return MainHandle; + + llvm::Type *HandleTy = CGM.getTypes().ConvertType(E->getType()); + Value *OrderID = EmitScalarExpr(E->getArg(1)); + Value *SpaceOp = EmitScalarExpr(E->getArg(2)); + llvm::Intrinsic::ID IntrinsicID = + llvm::Intrinsic::spv_resource_counterhandlefromimplicitbinding; + SmallVector<Value *> Args{MainHandle, OrderID, SpaceOp}; + return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args); + } case Builtin::BI__builtin_hlsl_resource_nonuniformindex: { Value *IndexOp = EmitScalarExpr(E->getArg(0)); llvm::Type *RetTy = ConvertType(E->getType()); diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp index ede1780..603cef9 100644 --- a/clang/lib/CodeGen/CGHLSLRuntime.cpp +++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp @@ -145,19 +145,29 @@ static CXXMethodDecl *lookupResourceInitMethodAndSetupArgs( // explicit binding auto *RegSlot = llvm::ConstantInt::get(CGM.IntTy, Binding.getSlot()); Args.add(RValue::get(RegSlot), AST.UnsignedIntTy); - CreateMethod = lookupMethod(ResourceDecl, "__createFromBinding", SC_Static); + const char *Name = Binding.hasCounterImplicitOrderID() + ? "__createFromBindingWithImplicitCounter" + : "__createFromBinding"; + CreateMethod = lookupMethod(ResourceDecl, Name, SC_Static); } else { // implicit binding auto *OrderID = llvm::ConstantInt::get(CGM.IntTy, Binding.getImplicitOrderID()); Args.add(RValue::get(OrderID), AST.UnsignedIntTy); - CreateMethod = - lookupMethod(ResourceDecl, "__createFromImplicitBinding", SC_Static); + const char *Name = Binding.hasCounterImplicitOrderID() + ? "__createFromImplicitBindingWithImplicitCounter" + : "__createFromImplicitBinding"; + CreateMethod = lookupMethod(ResourceDecl, Name, SC_Static); } Args.add(RValue::get(Space), AST.UnsignedIntTy); Args.add(RValue::get(Range), AST.IntTy); Args.add(RValue::get(Index), AST.UnsignedIntTy); Args.add(RValue::get(NameStr), AST.getPointerType(AST.CharTy.withConst())); + if (Binding.hasCounterImplicitOrderID()) { + uint32_t CounterBinding = Binding.getCounterImplicitOrderID(); + auto *CounterOrderID = llvm::ConstantInt::get(CGM.IntTy, CounterBinding); + Args.add(RValue::get(CounterOrderID), AST.UnsignedIntTy); + } return CreateMethod; } diff --git a/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp b/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp index 4272d8b..3613b6a 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp @@ -869,6 +869,8 @@ CGOpenMPRuntimeGPU::CGOpenMPRuntimeGPU(CodeGenModule &CGM) CGM.getLangOpts().OpenMPOffloadMandatory, /*HasRequiresReverseOffload*/ false, /*HasRequiresUnifiedAddress*/ false, hasRequiresUnifiedSharedMemory(), /*HasRequiresDynamicAllocators*/ false); + Config.setDefaultTargetAS( + CGM.getContext().getTargetInfo().getTargetAddressSpace(LangAS::Default)); OMPBuilder.setConfig(Config); if (!CGM.getLangOpts().OpenMPIsTargetDevice) @@ -1243,7 +1245,10 @@ void CGOpenMPRuntimeGPU::emitParallelCall( llvm::Value *ID = llvm::ConstantPointerNull::get(CGM.Int8PtrTy); if (WFn) ID = Bld.CreateBitOrPointerCast(WFn, CGM.Int8PtrTy); - llvm::Value *FnPtr = Bld.CreateBitOrPointerCast(OutlinedFn, CGM.Int8PtrTy); + llvm::Type *FnPtrTy = llvm::PointerType::get( + CGF.getLLVMContext(), CGM.getDataLayout().getProgramAddressSpace()); + + llvm::Value *FnPtr = Bld.CreateBitOrPointerCast(OutlinedFn, FnPtrTy); // Create a private scope that will globalize the arguments // passed from the outside of the target region. diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index b2fe917..acf8de4 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -846,6 +846,8 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, Fn->addFnAttr(llvm::Attribute::SanitizeNumericalStability); if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory)) Fn->addFnAttr(llvm::Attribute::SanitizeMemory); + if (SanOpts.has(SanitizerKind::AllocToken)) + Fn->addFnAttr(llvm::Attribute::SanitizeAllocToken); } if (SanOpts.has(SanitizerKind::SafeStack)) Fn->addFnAttr(llvm::Attribute::SafeStack); diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 99de6e1..1f0be2d 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -346,6 +346,10 @@ public: QualType FnRetTy; llvm::Function *CurFn = nullptr; + /// If a cast expression is being visited, this holds the current cast's + /// expression. + const CastExpr *CurCast = nullptr; + /// Save Parameter Decl for coroutine. llvm::SmallVector<const ParmVarDecl *, 4> FnArgs; @@ -3348,6 +3352,12 @@ public: SanitizerAnnotateDebugInfo(ArrayRef<SanitizerKind::SanitizerOrdinal> Ordinals, SanitizerHandler Handler); + /// Emit additional metadata used by the AllocToken instrumentation. + void EmitAllocToken(llvm::CallBase *CB, QualType AllocType); + /// Emit additional metadata used by the AllocToken instrumentation, + /// inferring the type from an allocation call expression. + void EmitAllocToken(llvm::CallBase *CB, const CallExpr *E); + llvm::Value *GetCountedByFieldExprGEP(const Expr *Base, const FieldDecl *FD, const FieldDecl *CountDecl); diff --git a/clang/lib/CodeGen/Targets/SPIR.cpp b/clang/lib/CodeGen/Targets/SPIR.cpp index 4aa6314..3f6d4e0 100644 --- a/clang/lib/CodeGen/Targets/SPIR.cpp +++ b/clang/lib/CodeGen/Targets/SPIR.cpp @@ -61,6 +61,9 @@ public: QualType SampledType, CodeGenModule &CGM) const; void setOCLKernelStubCallingConvention(const FunctionType *&FT) const override; + llvm::Constant *getNullPointer(const CodeGen::CodeGenModule &CGM, + llvm::PointerType *T, + QualType QT) const override; }; class SPIRVTargetCodeGenInfo : public CommonSPIRTargetCodeGenInfo { public: @@ -240,6 +243,29 @@ void CommonSPIRTargetCodeGenInfo::setOCLKernelStubCallingConvention( FT, FT->getExtInfo().withCallingConv(CC_SpirFunction)); } +// LLVM currently assumes a null pointer has the bit pattern 0, but some GPU +// targets use a non-zero encoding for null in certain address spaces. +// Because SPIR(-V) is a generic target and the bit pattern of null in +// non-generic AS is unspecified, materialize null in non-generic AS via an +// addrspacecast from null in generic AS. This allows later lowering to +// substitute the target's real sentinel value. +llvm::Constant * +CommonSPIRTargetCodeGenInfo::getNullPointer(const CodeGen::CodeGenModule &CGM, + llvm::PointerType *PT, + QualType QT) const { + LangAS AS = QT->getUnqualifiedDesugaredType()->isNullPtrType() + ? LangAS::Default + : QT->getPointeeType().getAddressSpace(); + if (AS == LangAS::Default || AS == LangAS::opencl_generic) + return llvm::ConstantPointerNull::get(PT); + + auto &Ctx = CGM.getContext(); + auto NPT = llvm::PointerType::get( + PT->getContext(), Ctx.getTargetAddressSpace(LangAS::opencl_generic)); + return llvm::ConstantExpr::getAddrSpaceCast( + llvm::ConstantPointerNull::get(NPT), PT); +} + LangAS SPIRVTargetCodeGenInfo::getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const { diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp index 7ce1afe..5dd48f5 100644 --- a/clang/lib/Driver/SanitizerArgs.cpp +++ b/clang/lib/Driver/SanitizerArgs.cpp @@ -61,8 +61,9 @@ static const SanitizerMask RecoverableByDefault = SanitizerKind::ImplicitConversion | SanitizerKind::Nullability | SanitizerKind::FloatDivideByZero | SanitizerKind::ObjCCast | SanitizerKind::Vptr; -static const SanitizerMask Unrecoverable = - SanitizerKind::Unreachable | SanitizerKind::Return; +static const SanitizerMask Unrecoverable = SanitizerKind::Unreachable | + SanitizerKind::Return | + SanitizerKind::AllocToken; static const SanitizerMask AlwaysRecoverable = SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress | SanitizerKind::KCFI; @@ -84,7 +85,8 @@ static const SanitizerMask CFIClasses = static const SanitizerMask CompatibleWithMinimalRuntime = TrappingSupported | SanitizerKind::Scudo | SanitizerKind::ShadowCallStack | SanitizerKind::MemtagStack | SanitizerKind::MemtagHeap | - SanitizerKind::MemtagGlobals | SanitizerKind::KCFI; + SanitizerKind::MemtagGlobals | SanitizerKind::KCFI | + SanitizerKind::AllocToken; enum CoverageFeature { CoverageFunc = 1 << 0, @@ -203,6 +205,7 @@ static void addDefaultIgnorelists(const Driver &D, SanitizerMask Kinds, {"tysan_blacklist.txt", SanitizerKind::Type}, {"dfsan_abilist.txt", SanitizerKind::DataFlow}, {"cfi_ignorelist.txt", SanitizerKind::CFI}, + {"alloc_token_ignorelist.txt", SanitizerKind::AllocToken}, {"ubsan_ignorelist.txt", SanitizerKind::Undefined | SanitizerKind::Vptr | SanitizerKind::Integer | SanitizerKind::Nullability | @@ -650,7 +653,12 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function), std::make_pair(SanitizerKind::Realtime, SanitizerKind::Address | SanitizerKind::Thread | - SanitizerKind::Undefined | SanitizerKind::Memory)}; + SanitizerKind::Undefined | SanitizerKind::Memory), + std::make_pair(SanitizerKind::AllocToken, + SanitizerKind::Address | SanitizerKind::HWAddress | + SanitizerKind::KernelAddress | + SanitizerKind::KernelHWAddress | + SanitizerKind::Memory)}; // Enable toolchain specific default sanitizers if not explicitly disabled. SanitizerMask Default = TC.getDefaultSanitizers() & ~AllRemove; @@ -1159,6 +1167,15 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, !TC.getTriple().isAndroid() && !TC.getTriple().isOSFuchsia(); } + if (AllAddedKinds & SanitizerKind::AllocToken) { + AllocTokenFastABI = Args.hasFlag( + options::OPT_fsanitize_alloc_token_fast_abi, + options::OPT_fno_sanitize_alloc_token_fast_abi, AllocTokenFastABI); + AllocTokenExtended = Args.hasFlag( + options::OPT_fsanitize_alloc_token_extended, + options::OPT_fno_sanitize_alloc_token_extended, AllocTokenExtended); + } + LinkRuntimes = Args.hasFlag(options::OPT_fsanitize_link_runtime, options::OPT_fno_sanitize_link_runtime, !Args.hasArg(options::OPT_r)); @@ -1527,6 +1544,12 @@ void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, Sanitizers.has(SanitizerKind::Address)) CmdArgs.push_back("-fno-assume-sane-operator-new"); + // Flags for -fsanitize=alloc-token. + if (AllocTokenFastABI) + CmdArgs.push_back("-fsanitize-alloc-token-fast-abi"); + if (AllocTokenExtended) + CmdArgs.push_back("-fsanitize-alloc-token-extended"); + // libFuzzer wants to intercept calls to certain library functions, so the // following -fno-builtin-* flags force the compiler to emit interposable // libcalls to these functions. Other sanitizers effectively do the same thing diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index a9041d2..3d5cac6 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1623,7 +1623,8 @@ SanitizerMask ToolChain::getSupportedSanitizers() const { SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero | SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow | SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion | - SanitizerKind::Nullability | SanitizerKind::LocalBounds; + SanitizerKind::Nullability | SanitizerKind::LocalBounds | + SanitizerKind::AllocToken; if (getTriple().getArch() == llvm::Triple::x86 || getTriple().getArch() == llvm::Triple::x86_64 || getTriple().getArch() == llvm::Triple::arm || diff --git a/clang/lib/Driver/ToolChains/Arch/RISCV.cpp b/clang/lib/Driver/ToolChains/Arch/RISCV.cpp index 76dde0d..f2e79e7 100644 --- a/clang/lib/Driver/ToolChains/Arch/RISCV.cpp +++ b/clang/lib/Driver/ToolChains/Arch/RISCV.cpp @@ -49,11 +49,8 @@ static bool getArchFeatures(const Driver &D, StringRef Arch, return true; } -// Get features except standard extension feature -static void getRISCFeaturesFromMcpu(const Driver &D, const Arg *A, - const llvm::Triple &Triple, - StringRef Mcpu, - std::vector<StringRef> &Features) { +static bool isValidRISCVCPU(const Driver &D, const Arg *A, + const llvm::Triple &Triple, StringRef Mcpu) { bool Is64Bit = Triple.isRISCV64(); if (!llvm::RISCV::parseCPU(Mcpu, Is64Bit)) { // Try inverting Is64Bit in case the CPU is valid, but for the wrong target. @@ -63,7 +60,9 @@ static void getRISCFeaturesFromMcpu(const Driver &D, const Arg *A, else D.Diag(clang::diag::err_drv_unsupported_option_argument) << A->getSpelling() << Mcpu; + return false; } + return true; } void riscv::getRISCVTargetFeatures(const Driver &D, const llvm::Triple &Triple, @@ -84,7 +83,8 @@ void riscv::getRISCVTargetFeatures(const Driver &D, const llvm::Triple &Triple, if (CPU == "native") CPU = llvm::sys::getHostCPUName(); - getRISCFeaturesFromMcpu(D, A, Triple, CPU, Features); + if (!isValidRISCVCPU(D, A, Triple, CPU)) + return; if (llvm::RISCV::hasFastScalarUnalignedAccess(CPU)) CPUFastScalarUnaligned = true; diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 107b9ff..d326a81 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -7618,6 +7618,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // features enabled through -Xclang -target-feature flags. SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType); + Args.AddLastArg(CmdArgs, options::OPT_falloc_token_max_EQ); + #if CLANG_ENABLE_CIR // Forward -mmlir arguments to to the MLIR option parser. for (const Arg *A : Args.filtered(options::OPT_mmlir)) { diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 49ee53f..16cc1db 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -2231,7 +2231,7 @@ static unsigned ParseDebugDefaultVersion(const ToolChain &TC, return 0; unsigned Value = 0; - if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 5 || + if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 6 || Value < 2) TC.getDriver().Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << A->getValue(); @@ -2244,13 +2244,14 @@ unsigned tools::DwarfVersionNum(StringRef ArgValue) { .Case("-gdwarf-3", 3) .Case("-gdwarf-4", 4) .Case("-gdwarf-5", 5) + .Case("-gdwarf-6", 6) .Default(0); } const Arg *tools::getDwarfNArg(const ArgList &Args) { return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3, options::OPT_gdwarf_4, options::OPT_gdwarf_5, - options::OPT_gdwarf); + options::OPT_gdwarf_6, options::OPT_gdwarf); } unsigned tools::getDwarfVersion(const ToolChain &TC, diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp index 234683f..d2356eb 100644 --- a/clang/lib/Driver/ToolChains/Darwin.cpp +++ b/clang/lib/Driver/ToolChains/Darwin.cpp @@ -1609,7 +1609,12 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) { AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", /*shared=*/false); - // Libfuzzer is written in C++ and requires libcxx. + // Libfuzzer is written in C++ and requires libcxx. + // Since darwin::Linker::ConstructJob already adds -lc++ for clang++ + // by default if ShouldLinkCXXStdlib(Args), we only add the option if + // !ShouldLinkCXXStdlib(Args). This avoids duplicate library errors + // on Darwin. + if (!ShouldLinkCXXStdlib(Args)) AddCXXStdlibLibArgs(Args, CmdArgs); } if (Sanitize.needsStatsRt()) { diff --git a/clang/lib/Driver/ToolChains/HIPAMD.cpp b/clang/lib/Driver/ToolChains/HIPAMD.cpp index 5f3fbea..c0c8afe 100644 --- a/clang/lib/Driver/ToolChains/HIPAMD.cpp +++ b/clang/lib/Driver/ToolChains/HIPAMD.cpp @@ -168,9 +168,12 @@ void AMDGCN::Linker::constructLinkAndEmitSpirvCommand( const InputInfo &Output, const llvm::opt::ArgList &Args) const { assert(!Inputs.empty() && "Must have at least one input."); - constructLlvmLinkCommand(C, JA, Inputs, Output, Args); + std::string LinkedBCFilePrefix( + Twine(llvm::sys::path::stem(Output.getFilename()), "-linked").str()); + const char *LinkedBCFilePath = HIP::getTempFile(C, LinkedBCFilePrefix, "bc"); + InputInfo LinkedBCFile(&JA, LinkedBCFilePath, Output.getBaseInput()); - // Linked BC is now in Output + constructLlvmLinkCommand(C, JA, Inputs, LinkedBCFile, Args); // Emit SPIR-V binary. llvm::opt::ArgStringList TrArgs{ @@ -180,7 +183,7 @@ void AMDGCN::Linker::constructLinkAndEmitSpirvCommand( "--spirv-lower-const-expr", "--spirv-preserve-auxdata", "--spirv-debug-info-version=nonsemantic-shader-200"}; - SPIRV::constructTranslateCommand(C, *this, JA, Output, Output, TrArgs); + SPIRV::constructTranslateCommand(C, *this, JA, Output, LinkedBCFile, TrArgs); } // For amdgcn the inputs of the linker job are device bitcode and output is diff --git a/clang/lib/Driver/ToolChains/HIPSPV.cpp b/clang/lib/Driver/ToolChains/HIPSPV.cpp index 62bca04..bce7f46 100644 --- a/clang/lib/Driver/ToolChains/HIPSPV.cpp +++ b/clang/lib/Driver/ToolChains/HIPSPV.cpp @@ -22,17 +22,6 @@ using namespace clang::driver::tools; using namespace clang; using namespace llvm::opt; -// Convenience function for creating temporary file for both modes of -// isSaveTempsEnabled(). -static const char *getTempFile(Compilation &C, StringRef Prefix, - StringRef Extension) { - if (C.getDriver().isSaveTempsEnabled()) { - return C.getArgs().MakeArgString(Prefix + "." + Extension); - } - auto TmpFile = C.getDriver().GetTemporaryPath(Prefix, Extension); - return C.addTempFile(C.getArgs().MakeArgString(TmpFile)); -} - // Locates HIP pass plugin. static std::string findPassPlugin(const Driver &D, const llvm::opt::ArgList &Args) { @@ -65,7 +54,7 @@ void HIPSPV::Linker::constructLinkAndEmitSpirvCommand( assert(!Inputs.empty() && "Must have at least one input."); std::string Name = std::string(llvm::sys::path::stem(Output.getFilename())); - const char *TempFile = getTempFile(C, Name + "-link", "bc"); + const char *TempFile = HIP::getTempFile(C, Name + "-link", "bc"); // Link LLVM bitcode. ArgStringList LinkArgs{}; @@ -93,7 +82,7 @@ void HIPSPV::Linker::constructLinkAndEmitSpirvCommand( auto PassPluginPath = findPassPlugin(C.getDriver(), Args); if (!PassPluginPath.empty()) { const char *PassPathCStr = C.getArgs().MakeArgString(PassPluginPath); - const char *OptOutput = getTempFile(C, Name + "-lower", "bc"); + const char *OptOutput = HIP::getTempFile(C, Name + "-lower", "bc"); ArgStringList OptArgs{TempFile, "-load-pass-plugin", PassPathCStr, "-passes=hip-post-link-passes", "-o", OptOutput}; diff --git a/clang/lib/Driver/ToolChains/HIPUtility.cpp b/clang/lib/Driver/ToolChains/HIPUtility.cpp index cb061ff..732403e 100644 --- a/clang/lib/Driver/ToolChains/HIPUtility.cpp +++ b/clang/lib/Driver/ToolChains/HIPUtility.cpp @@ -472,3 +472,14 @@ void HIP::constructGenerateObjFileFromHIPFatBinary( D.getClangProgramPath(), ClangArgs, Inputs, Output, D.getPrependArg())); } + +// Convenience function for creating temporary file for both modes of +// isSaveTempsEnabled(). +const char *HIP::getTempFile(Compilation &C, StringRef Prefix, + StringRef Extension) { + if (C.getDriver().isSaveTempsEnabled()) { + return C.getArgs().MakeArgString(Prefix + "." + Extension); + } + auto TmpFile = C.getDriver().GetTemporaryPath(Prefix, Extension); + return C.addTempFile(C.getArgs().MakeArgString(TmpFile)); +} diff --git a/clang/lib/Driver/ToolChains/HIPUtility.h b/clang/lib/Driver/ToolChains/HIPUtility.h index 29e5a92..55c155e 100644 --- a/clang/lib/Driver/ToolChains/HIPUtility.h +++ b/clang/lib/Driver/ToolChains/HIPUtility.h @@ -16,6 +16,8 @@ namespace driver { namespace tools { namespace HIP { +const char *getTempFile(Compilation &C, StringRef Prefix, StringRef Extension); + // Construct command for creating HIP fatbin. void constructHIPFatbinCommand(Compilation &C, const JobAction &JA, StringRef OutputFileName, diff --git a/clang/lib/Driver/ToolChains/UEFI.cpp b/clang/lib/Driver/ToolChains/UEFI.cpp index 75adbf1..d2be147 100644 --- a/clang/lib/Driver/ToolChains/UEFI.cpp +++ b/clang/lib/Driver/ToolChains/UEFI.cpp @@ -24,7 +24,9 @@ using namespace clang; using namespace llvm::opt; UEFI::UEFI(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) - : ToolChain(D, Triple, Args) {} + : ToolChain(D, Triple, Args) { + getProgramPaths().push_back(getDriver().Dir); +} Tool *UEFI::buildLinker() const { return new tools::uefi::Linker(*this); } diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp index 50fd50a..292adce 100644 --- a/clang/lib/Frontend/CompilerInvocation.cpp +++ b/clang/lib/Frontend/CompilerInvocation.cpp @@ -1833,6 +1833,10 @@ void CompilerInvocationBase::GenerateCodeGenArgs(const CodeGenOptions &Opts, serializeSanitizerKinds(Opts.SanitizeAnnotateDebugInfo)) GenerateArg(Consumer, OPT_fsanitize_annotate_debug_info_EQ, Sanitizer); + if (Opts.AllocTokenMax) + GenerateArg(Consumer, OPT_falloc_token_max_EQ, + std::to_string(*Opts.AllocTokenMax)); + if (!Opts.EmitVersionIdentMetadata) GenerateArg(Consumer, OPT_Qn); @@ -2346,6 +2350,15 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, } } + if (const auto *Arg = Args.getLastArg(options::OPT_falloc_token_max_EQ)) { + StringRef S = Arg->getValue(); + uint64_t Value = 0; + if (S.getAsInteger(0, Value)) + Diags.Report(diag::err_drv_invalid_value) << Arg->getAsString(Args) << S; + else + Opts.AllocTokenMax = Value; + } + Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true); if (!LangOpts->CUDAIsDevice) diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 877ab02..b899fb9 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -1530,6 +1530,8 @@ static void InitializePredefinedMacros(const TargetInfo &TI, Builder.defineMacro("__SANITIZE_HWADDRESS__"); if (LangOpts.Sanitize.has(SanitizerKind::Thread)) Builder.defineMacro("__SANITIZE_THREAD__"); + if (LangOpts.Sanitize.has(SanitizerKind::AllocToken)) + Builder.defineMacro("__SANITIZE_ALLOC_TOKEN__"); // Target OS macro definitions. if (PPOpts.DefineTargetOSMacros) { diff --git a/clang/lib/Headers/avx2intrin.h b/clang/lib/Headers/avx2intrin.h index 31759c5..4aaca2d 100644 --- a/clang/lib/Headers/avx2intrin.h +++ b/clang/lib/Headers/avx2intrin.h @@ -1035,10 +1035,9 @@ _mm256_hsubs_epi16(__m256i __a, __m256i __b) /// \param __b /// A 256-bit vector containing one of the source operands. /// \returns A 256-bit vector of [16 x i16] containing the result. -static __inline__ __m256i __DEFAULT_FN_ATTRS256 -_mm256_maddubs_epi16(__m256i __a, __m256i __b) -{ - return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)__a, (__v32qi)__b); +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR +_mm256_maddubs_epi16(__m256i __a, __m256i __b) { + return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)__a, (__v32qi)__b); } /// Multiplies corresponding 16-bit elements of two 256-bit vectors of @@ -1067,9 +1066,8 @@ _mm256_maddubs_epi16(__m256i __a, __m256i __b) /// \param __b /// A 256-bit vector of [16 x i16] containing one of the source operands. /// \returns A 256-bit vector of [8 x i32] containing the result. -static __inline__ __m256i __DEFAULT_FN_ATTRS256 -_mm256_madd_epi16(__m256i __a, __m256i __b) -{ +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR +_mm256_madd_epi16(__m256i __a, __m256i __b) { return (__m256i)__builtin_ia32_pmaddwd256((__v16hi)__a, (__v16hi)__b); } diff --git a/clang/lib/Headers/avx512bwintrin.h b/clang/lib/Headers/avx512bwintrin.h index c36bd81..473fe94 100644 --- a/clang/lib/Headers/avx512bwintrin.h +++ b/clang/lib/Headers/avx512bwintrin.h @@ -1064,12 +1064,12 @@ _mm512_maskz_mulhi_epu16(__mmask32 __U, __m512i __A, __m512i __B) { (__v32hi)_mm512_setzero_si512()); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_maddubs_epi16(__m512i __X, __m512i __Y) { return (__m512i)__builtin_ia32_pmaddubsw512((__v64qi)__X, (__v64qi)__Y); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_mask_maddubs_epi16(__m512i __W, __mmask32 __U, __m512i __X, __m512i __Y) { return (__m512i)__builtin_ia32_selectw_512((__mmask32) __U, @@ -1077,26 +1077,26 @@ _mm512_mask_maddubs_epi16(__m512i __W, __mmask32 __U, __m512i __X, (__v32hi)__W); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_maskz_maddubs_epi16(__mmask32 __U, __m512i __X, __m512i __Y) { return (__m512i)__builtin_ia32_selectw_512((__mmask32) __U, (__v32hi)_mm512_maddubs_epi16(__X, __Y), (__v32hi)_mm512_setzero_si512()); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_madd_epi16(__m512i __A, __m512i __B) { return (__m512i)__builtin_ia32_pmaddwd512((__v32hi)__A, (__v32hi)__B); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_mask_madd_epi16(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, (__v16si)_mm512_madd_epi16(__A, __B), (__v16si)__W); } -static __inline__ __m512i __DEFAULT_FN_ATTRS512 +static __inline__ __m512i __DEFAULT_FN_ATTRS512_CONSTEXPR _mm512_maskz_madd_epi16(__mmask16 __U, __m512i __A, __m512i __B) { return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U, (__v16si)_mm512_madd_epi16(__A, __B), diff --git a/clang/lib/Headers/avx512vlbwintrin.h b/clang/lib/Headers/avx512vlbwintrin.h index 5e6daa8..81e4cbb9 100644 --- a/clang/lib/Headers/avx512vlbwintrin.h +++ b/clang/lib/Headers/avx512vlbwintrin.h @@ -1295,21 +1295,21 @@ _mm256_maskz_permutex2var_epi16 (__mmask16 __U, __m256i __A, __m256i __I, (__v16hi)_mm256_setzero_si256()); } -static __inline__ __m128i __DEFAULT_FN_ATTRS128 +static __inline__ __m128i __DEFAULT_FN_ATTRS128_CONSTEXPR _mm_mask_maddubs_epi16(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U, (__v8hi)_mm_maddubs_epi16(__X, __Y), (__v8hi)__W); } -static __inline__ __m128i __DEFAULT_FN_ATTRS128 +static __inline__ __m128i __DEFAULT_FN_ATTRS128_CONSTEXPR _mm_maskz_maddubs_epi16(__mmask8 __U, __m128i __X, __m128i __Y) { return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U, (__v8hi)_mm_maddubs_epi16(__X, __Y), (__v8hi)_mm_setzero_si128()); } -static __inline__ __m256i __DEFAULT_FN_ATTRS256 +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR _mm256_mask_maddubs_epi16(__m256i __W, __mmask16 __U, __m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U, @@ -1317,35 +1317,35 @@ _mm256_mask_maddubs_epi16(__m256i __W, __mmask16 __U, __m256i __X, (__v16hi)__W); } -static __inline__ __m256i __DEFAULT_FN_ATTRS256 +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR _mm256_maskz_maddubs_epi16(__mmask16 __U, __m256i __X, __m256i __Y) { return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U, (__v16hi)_mm256_maddubs_epi16(__X, __Y), (__v16hi)_mm256_setzero_si256()); } -static __inline__ __m128i __DEFAULT_FN_ATTRS128 +static __inline__ __m128i __DEFAULT_FN_ATTRS128_CONSTEXPR _mm_mask_madd_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U, (__v4si)_mm_madd_epi16(__A, __B), (__v4si)__W); } -static __inline__ __m128i __DEFAULT_FN_ATTRS128 +static __inline__ __m128i __DEFAULT_FN_ATTRS128_CONSTEXPR _mm_maskz_madd_epi16(__mmask8 __U, __m128i __A, __m128i __B) { return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U, (__v4si)_mm_madd_epi16(__A, __B), (__v4si)_mm_setzero_si128()); } -static __inline__ __m256i __DEFAULT_FN_ATTRS256 +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR _mm256_mask_madd_epi16(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) { return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U, (__v8si)_mm256_madd_epi16(__A, __B), (__v8si)__W); } -static __inline__ __m256i __DEFAULT_FN_ATTRS256 +static __inline__ __m256i __DEFAULT_FN_ATTRS256_CONSTEXPR _mm256_maskz_madd_epi16(__mmask8 __U, __m256i __A, __m256i __B) { return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U, (__v8si)_mm256_madd_epi16(__A, __B), diff --git a/clang/lib/Headers/emmintrin.h b/clang/lib/Headers/emmintrin.h index 6597e7e..454e9a2 100644 --- a/clang/lib/Headers/emmintrin.h +++ b/clang/lib/Headers/emmintrin.h @@ -2290,8 +2290,8 @@ _mm_avg_epu16(__m128i __a, __m128i __b) { /// A 128-bit signed [8 x i16] vector. /// \returns A 128-bit signed [4 x i32] vector containing the sums of products /// of both parameters. -static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_madd_epi16(__m128i __a, - __m128i __b) { +static __inline__ __m128i __DEFAULT_FN_ATTRS_CONSTEXPR +_mm_madd_epi16(__m128i __a, __m128i __b) { return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)__a, (__v8hi)__b); } diff --git a/clang/lib/Headers/mmintrin.h b/clang/lib/Headers/mmintrin.h index 5f61753..aca78e6 100644 --- a/clang/lib/Headers/mmintrin.h +++ b/clang/lib/Headers/mmintrin.h @@ -679,11 +679,10 @@ _mm_subs_pu16(__m64 __m1, __m64 __m2) { /// A 64-bit integer vector of [4 x i16]. /// \returns A 64-bit integer vector of [2 x i32] containing the sums of /// products of both parameters. -static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 -_mm_madd_pi16(__m64 __m1, __m64 __m2) -{ - return __trunc64(__builtin_ia32_pmaddwd128((__v8hi)__anyext128(__m1), - (__v8hi)__anyext128(__m2))); +static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR +_mm_madd_pi16(__m64 __m1, __m64 __m2) { + return __trunc64(__builtin_ia32_pmaddwd128((__v8hi)__zext128(__m1), + (__v8hi)__zext128(__m2))); } /// Multiplies each 16-bit signed integer element of the first 64-bit diff --git a/clang/lib/Headers/tmmintrin.h b/clang/lib/Headers/tmmintrin.h index d40f0c5..3fc9f98 100644 --- a/clang/lib/Headers/tmmintrin.h +++ b/clang/lib/Headers/tmmintrin.h @@ -23,6 +23,9 @@ #define __trunc64(x) \ (__m64) __builtin_shufflevector((__v2di)(x), __extension__(__v2di){}, 0) +#define __zext128(x) \ + (__m128i) __builtin_shufflevector((__v2si)(x), __extension__(__v2si){}, 0, \ + 1, 2, 3) #define __anyext128(x) \ (__m128i) __builtin_shufflevector((__v2si)(x), __extension__(__v2si){}, 0, \ 1, -1, -1) @@ -504,10 +507,9 @@ _mm_hsubs_pi16(__m64 __a, __m64 __b) /// \a R5 := (\a __a10 * \a __b10) + (\a __a11 * \a __b11) \n /// \a R6 := (\a __a12 * \a __b12) + (\a __a13 * \a __b13) \n /// \a R7 := (\a __a14 * \a __b14) + (\a __a15 * \a __b15) -static __inline__ __m128i __DEFAULT_FN_ATTRS -_mm_maddubs_epi16(__m128i __a, __m128i __b) -{ - return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)__a, (__v16qi)__b); +static __inline__ __m128i __DEFAULT_FN_ATTRS_CONSTEXPR +_mm_maddubs_epi16(__m128i __a, __m128i __b) { + return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)__a, (__v16qi)__b); } /// Multiplies corresponding pairs of packed 8-bit unsigned integer @@ -534,11 +536,10 @@ _mm_maddubs_epi16(__m128i __a, __m128i __b) /// \a R1 := (\a __a2 * \a __b2) + (\a __a3 * \a __b3) \n /// \a R2 := (\a __a4 * \a __b4) + (\a __a5 * \a __b5) \n /// \a R3 := (\a __a6 * \a __b6) + (\a __a7 * \a __b7) -static __inline__ __m64 __DEFAULT_FN_ATTRS -_mm_maddubs_pi16(__m64 __a, __m64 __b) -{ - return __trunc64(__builtin_ia32_pmaddubsw128((__v16qi)__anyext128(__a), - (__v16qi)__anyext128(__b))); +static __inline__ __m64 __DEFAULT_FN_ATTRS_CONSTEXPR +_mm_maddubs_pi16(__m64 __a, __m64 __b) { + return __trunc64(__builtin_ia32_pmaddubsw128((__v16qi)__zext128(__a), + (__v16qi)__zext128(__b))); } /// Multiplies packed 16-bit signed integer values, truncates the 32-bit @@ -796,6 +797,7 @@ _mm_sign_pi32(__m64 __a, __m64 __b) } #undef __anyext128 +#undef __zext128 #undef __trunc64 #undef __DEFAULT_FN_ATTRS #undef __DEFAULT_FN_ATTRS_CONSTEXPR diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp index a2c6957..90191b0 100644 --- a/clang/lib/Parse/ParseExprCXX.cpp +++ b/clang/lib/Parse/ParseExprCXX.cpp @@ -3200,6 +3200,8 @@ ExprResult Parser::ParseRequiresExpression() { BalancedDelimiterTracker ExprBraces(*this, tok::l_brace); ExprBraces.consumeOpen(); ExprResult Expression = ParseExpression(); + if (Expression.isUsable()) + Expression = Actions.CheckPlaceholderExpr(Expression.get()); if (!Expression.isUsable()) { ExprBraces.skipToEnd(); SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); @@ -3369,6 +3371,8 @@ ExprResult Parser::ParseRequiresExpression() { // expression ';' SourceLocation StartLoc = Tok.getLocation(); ExprResult Expression = ParseExpression(); + if (Expression.isUsable()) + Expression = Actions.CheckPlaceholderExpr(Expression.get()); if (!Expression.isUsable()) { SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); break; diff --git a/clang/lib/Sema/AnalysisBasedWarnings.cpp b/clang/lib/Sema/AnalysisBasedWarnings.cpp index 8606227..e9ca8ce 100644 --- a/clang/lib/Sema/AnalysisBasedWarnings.cpp +++ b/clang/lib/Sema/AnalysisBasedWarnings.cpp @@ -2605,6 +2605,17 @@ public: #endif } + void handleUnsafeUniquePtrArrayAccess(const DynTypedNode &Node, + bool IsRelatedToDecl, + ASTContext &Ctx) override { + SourceLocation Loc; + std::string Message; + + Loc = Node.get<Stmt>()->getBeginLoc(); + S.Diag(Loc, diag::warn_unsafe_buffer_usage_unique_ptr_array_access) + << Node.getSourceRange(); + } + bool isSafeBufferOptOut(const SourceLocation &Loc) const override { return S.PP.isSafeBufferOptOut(S.getSourceManager(), Loc); } diff --git a/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.cpp b/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.cpp index 3c20ccd..40c318a 100644 --- a/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.cpp +++ b/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.cpp @@ -144,6 +144,7 @@ private: _2, _3, _4, + _5, Handle = 128, CounterHandle, LastStmt @@ -190,6 +191,9 @@ public: template <typename T> BuiltinTypeMethodBuilder & accessCounterHandleFieldOnResource(T ResourceRecord); + template <typename ResourceT, typename ValueT> + BuiltinTypeMethodBuilder & + setCounterHandleFieldOnResource(ResourceT ResourceRecord, ValueT HandleValue); template <typename T> BuiltinTypeMethodBuilder &returnValue(T ReturnValue); BuiltinTypeMethodBuilder &returnThis(); BuiltinTypeDeclBuilder &finalize(); @@ -205,6 +209,11 @@ private: if (!Method) createDecl(); } + + template <typename ResourceT, typename ValueT> + BuiltinTypeMethodBuilder &setFieldOnResource(ResourceT ResourceRecord, + ValueT HandleValue, + FieldDecl *HandleField); }; TemplateParameterListBuilder::~TemplateParameterListBuilder() { @@ -592,13 +601,27 @@ template <typename ResourceT, typename ValueT> BuiltinTypeMethodBuilder & BuiltinTypeMethodBuilder::setHandleFieldOnResource(ResourceT ResourceRecord, ValueT HandleValue) { + return setFieldOnResource(ResourceRecord, HandleValue, + DeclBuilder.getResourceHandleField()); +} + +template <typename ResourceT, typename ValueT> +BuiltinTypeMethodBuilder & +BuiltinTypeMethodBuilder::setCounterHandleFieldOnResource( + ResourceT ResourceRecord, ValueT HandleValue) { + return setFieldOnResource(ResourceRecord, HandleValue, + DeclBuilder.getResourceCounterHandleField()); +} + +template <typename ResourceT, typename ValueT> +BuiltinTypeMethodBuilder &BuiltinTypeMethodBuilder::setFieldOnResource( + ResourceT ResourceRecord, ValueT HandleValue, FieldDecl *HandleField) { ensureCompleteDecl(); Expr *ResourceExpr = convertPlaceholder(ResourceRecord); Expr *HandleValueExpr = convertPlaceholder(HandleValue); ASTContext &AST = DeclBuilder.SemaRef.getASTContext(); - FieldDecl *HandleField = DeclBuilder.getResourceHandleField(); MemberExpr *HandleMemberExpr = MemberExpr::CreateImplicit( AST, ResourceExpr, false, HandleField, HandleField->getType(), VK_LValue, OK_Ordinary); @@ -829,6 +852,18 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addDefaultHandleConstructor() { .finalize(); } +BuiltinTypeDeclBuilder & +BuiltinTypeDeclBuilder::addStaticInitializationFunctions(bool HasCounter) { + if (HasCounter) { + addCreateFromBindingWithImplicitCounter(); + addCreateFromImplicitBindingWithImplicitCounter(); + } else { + addCreateFromBinding(); + addCreateFromImplicitBinding(); + } + return *this; +} + // Adds static method that initializes resource from binding: // // static Resource<T> __createFromBinding(unsigned registerNo, @@ -903,6 +938,102 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addCreateFromImplicitBinding() { .finalize(); } +// Adds static method that initializes resource from binding: +// +// static Resource<T> +// __createFromBindingWithImplicitCounter(unsigned registerNo, +// unsigned spaceNo, int range, +// unsigned index, const char *name, +// unsigned counterOrderId) { +// Resource<T> tmp; +// tmp.__handle = __builtin_hlsl_resource_handlefrombinding( +// tmp.__handle, registerNo, spaceNo, range, index, name); +// tmp.__counter_handle = +// __builtin_hlsl_resource_counterhandlefromimplicitbinding( +// tmp.__handle, counterOrderId, spaceNo); +// return tmp; +// } +BuiltinTypeDeclBuilder & +BuiltinTypeDeclBuilder::addCreateFromBindingWithImplicitCounter() { + assert(!Record->isCompleteDefinition() && "record is already complete"); + + using PH = BuiltinTypeMethodBuilder::PlaceHolder; + ASTContext &AST = SemaRef.getASTContext(); + QualType HandleType = getResourceHandleField()->getType(); + QualType RecordType = AST.getTypeDeclType(cast<TypeDecl>(Record)); + BuiltinTypeMethodBuilder::LocalVar TmpVar("tmp", RecordType); + + return BuiltinTypeMethodBuilder(*this, + "__createFromBindingWithImplicitCounter", + RecordType, false, false, SC_Static) + .addParam("registerNo", AST.UnsignedIntTy) + .addParam("spaceNo", AST.UnsignedIntTy) + .addParam("range", AST.IntTy) + .addParam("index", AST.UnsignedIntTy) + .addParam("name", AST.getPointerType(AST.CharTy.withConst())) + .addParam("counterOrderId", AST.UnsignedIntTy) + .declareLocalVar(TmpVar) + .accessHandleFieldOnResource(TmpVar) + .callBuiltin("__builtin_hlsl_resource_handlefrombinding", HandleType, + PH::LastStmt, PH::_0, PH::_1, PH::_2, PH::_3, PH::_4) + .setHandleFieldOnResource(TmpVar, PH::LastStmt) + .accessHandleFieldOnResource(TmpVar) + .callBuiltin("__builtin_hlsl_resource_counterhandlefromimplicitbinding", + HandleType, PH::LastStmt, PH::_5, PH::_1) + .setCounterHandleFieldOnResource(TmpVar, PH::LastStmt) + .returnValue(TmpVar) + .finalize(); +} + +// Adds static method that initializes resource from binding: +// +// static Resource<T> +// __createFromImplicitBindingWithImplicitCounter(unsigned orderId, +// unsigned spaceNo, int range, +// unsigned index, +// const char *name, +// unsigned counterOrderId) { +// Resource<T> tmp; +// tmp.__handle = __builtin_hlsl_resource_handlefromimplicitbinding( +// tmp.__handle, orderId, spaceNo, range, index, name); +// tmp.__counter_handle = +// __builtin_hlsl_resource_counterhandlefromimplicitbinding( +// tmp.__handle, counterOrderId, spaceNo); +// return tmp; +// } +BuiltinTypeDeclBuilder & +BuiltinTypeDeclBuilder::addCreateFromImplicitBindingWithImplicitCounter() { + assert(!Record->isCompleteDefinition() && "record is already complete"); + + using PH = BuiltinTypeMethodBuilder::PlaceHolder; + ASTContext &AST = SemaRef.getASTContext(); + QualType HandleType = getResourceHandleField()->getType(); + QualType RecordType = AST.getTypeDeclType(cast<TypeDecl>(Record)); + BuiltinTypeMethodBuilder::LocalVar TmpVar("tmp", RecordType); + + return BuiltinTypeMethodBuilder( + *this, "__createFromImplicitBindingWithImplicitCounter", + RecordType, false, false, SC_Static) + .addParam("orderId", AST.UnsignedIntTy) + .addParam("spaceNo", AST.UnsignedIntTy) + .addParam("range", AST.IntTy) + .addParam("index", AST.UnsignedIntTy) + .addParam("name", AST.getPointerType(AST.CharTy.withConst())) + .addParam("counterOrderId", AST.UnsignedIntTy) + .declareLocalVar(TmpVar) + .accessHandleFieldOnResource(TmpVar) + .callBuiltin("__builtin_hlsl_resource_handlefromimplicitbinding", + HandleType, PH::LastStmt, PH::_0, PH::_1, PH::_2, PH::_3, + PH::_4) + .setHandleFieldOnResource(TmpVar, PH::LastStmt) + .accessHandleFieldOnResource(TmpVar) + .callBuiltin("__builtin_hlsl_resource_counterhandlefromimplicitbinding", + HandleType, PH::LastStmt, PH::_5, PH::_1) + .setCounterHandleFieldOnResource(TmpVar, PH::LastStmt) + .returnValue(TmpVar) + .finalize(); +} + BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addCopyConstructor() { assert(!Record->isCompleteDefinition() && "record is already complete"); @@ -1048,7 +1179,7 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addIncrementCounterMethod() { return BuiltinTypeMethodBuilder(*this, "IncrementCounter", SemaRef.getASTContext().UnsignedIntTy) .callBuiltin("__builtin_hlsl_buffer_update_counter", QualType(), - PH::Handle, getConstantIntExpr(1)) + PH::CounterHandle, getConstantIntExpr(1)) .finalize(); } @@ -1057,7 +1188,7 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addDecrementCounterMethod() { return BuiltinTypeMethodBuilder(*this, "DecrementCounter", SemaRef.getASTContext().UnsignedIntTy) .callBuiltin("__builtin_hlsl_buffer_update_counter", QualType(), - PH::Handle, getConstantIntExpr(-1)) + PH::CounterHandle, getConstantIntExpr(-1)) .finalize(); } @@ -1102,7 +1233,7 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addAppendMethod() { return BuiltinTypeMethodBuilder(*this, "Append", AST.VoidTy) .addParam("value", ElemTy) .callBuiltin("__builtin_hlsl_buffer_update_counter", AST.UnsignedIntTy, - PH::Handle, getConstantIntExpr(1)) + PH::CounterHandle, getConstantIntExpr(1)) .callBuiltin("__builtin_hlsl_resource_getpointer", AST.getPointerType(AddrSpaceElemTy), PH::Handle, PH::LastStmt) @@ -1119,7 +1250,7 @@ BuiltinTypeDeclBuilder &BuiltinTypeDeclBuilder::addConsumeMethod() { AST.getAddrSpaceQualType(ElemTy, LangAS::hlsl_device); return BuiltinTypeMethodBuilder(*this, "Consume", ElemTy) .callBuiltin("__builtin_hlsl_buffer_update_counter", AST.UnsignedIntTy, - PH::Handle, getConstantIntExpr(-1)) + PH::CounterHandle, getConstantIntExpr(-1)) .callBuiltin("__builtin_hlsl_resource_getpointer", AST.getPointerType(AddrSpaceElemTy), PH::Handle, PH::LastStmt) diff --git a/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.h b/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.h index a981602..86cbd10 100644 --- a/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.h +++ b/clang/lib/Sema/HLSLBuiltinTypeDeclBuilder.h @@ -83,8 +83,7 @@ public: BuiltinTypeDeclBuilder &addCopyAssignmentOperator(); // Static create methods - BuiltinTypeDeclBuilder &addCreateFromBinding(); - BuiltinTypeDeclBuilder &addCreateFromImplicitBinding(); + BuiltinTypeDeclBuilder &addStaticInitializationFunctions(bool HasCounter); // Builtin types methods BuiltinTypeDeclBuilder &addLoadMethods(); @@ -96,6 +95,10 @@ public: BuiltinTypeDeclBuilder &addConsumeMethod(); private: + BuiltinTypeDeclBuilder &addCreateFromBinding(); + BuiltinTypeDeclBuilder &addCreateFromImplicitBinding(); + BuiltinTypeDeclBuilder &addCreateFromBindingWithImplicitCounter(); + BuiltinTypeDeclBuilder &addCreateFromImplicitBindingWithImplicitCounter(); BuiltinTypeDeclBuilder &addResourceMember(StringRef MemberName, ResourceClass RC, bool IsROV, bool RawBuffer, bool IsCounter, diff --git a/clang/lib/Sema/HLSLExternalSemaSource.cpp b/clang/lib/Sema/HLSLExternalSemaSource.cpp index cc43e94..e118dda 100644 --- a/clang/lib/Sema/HLSLExternalSemaSource.cpp +++ b/clang/lib/Sema/HLSLExternalSemaSource.cpp @@ -236,8 +236,7 @@ static BuiltinTypeDeclBuilder setupBufferType(CXXRecordDecl *Decl, Sema &S, .addDefaultHandleConstructor() .addCopyConstructor() .addCopyAssignmentOperator() - .addCreateFromBinding() - .addCreateFromImplicitBinding(); + .addStaticInitializationFunctions(HasCounter); } // This function is responsible for constructing the constraint expression for diff --git a/clang/lib/Sema/SemaARM.cpp b/clang/lib/Sema/SemaARM.cpp index e09c352..1c7c832d 100644 --- a/clang/lib/Sema/SemaARM.cpp +++ b/clang/lib/Sema/SemaARM.cpp @@ -603,8 +603,8 @@ static bool checkArmStreamingBuiltin(Sema &S, CallExpr *TheCall, bool SatisfiesSME = Builtin::evaluateRequiredTargetFeatures( StreamingBuiltinGuard, CallerFeatures); - if ((SatisfiesSVE && SatisfiesSME) || - (SatisfiesSVE && FnType == SemaARM::ArmStreamingCompatible)) + if (SatisfiesSVE && SatisfiesSME) + // Function type is irrelevant for streaming-agnostic builtins. return false; else if (SatisfiesSVE) BuiltinType = SemaARM::ArmNonStreaming; diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 4d3c7d6..4230ea7 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -9014,24 +9014,6 @@ bool Sema::IsInvalidSMECallConversion(QualType FromType, QualType ToType) { return FromAttributes != ToAttributes; } -// Check if we have a conversion between incompatible cmse function pointer -// types, that is, a conversion between a function pointer with the -// cmse_nonsecure_call attribute and one without. -static bool IsInvalidCmseNSCallConversion(Sema &S, QualType FromType, - QualType ToType) { - if (const auto *ToFn = - dyn_cast<FunctionType>(S.Context.getCanonicalType(ToType))) { - if (const auto *FromFn = - dyn_cast<FunctionType>(S.Context.getCanonicalType(FromType))) { - FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo(); - FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo(); - - return ToEInfo.getCmseNSCall() != FromEInfo.getCmseNSCall(); - } - } - return false; -} - // checkPointerTypesForAssignment - This is a very tricky routine (despite // being closely modeled after the C99 spec:-). The odd characteristic of this // routine is it effectively iqnores the qualifiers on the top level pointee. @@ -9187,18 +9169,43 @@ static AssignConvertType checkPointerTypesForAssignment(Sema &S, return AssignConvertType::IncompatibleFunctionPointer; return AssignConvertType::IncompatiblePointer; } - bool DiscardingCFIUncheckedCallee, AddingCFIUncheckedCallee; - if (!S.getLangOpts().CPlusPlus && - S.IsFunctionConversion(ltrans, rtrans, &DiscardingCFIUncheckedCallee, - &AddingCFIUncheckedCallee)) { - // Allow conversions between CFIUncheckedCallee-ness. - if (!DiscardingCFIUncheckedCallee && !AddingCFIUncheckedCallee) + // Note: in C++, typesAreCompatible(ltrans, rtrans) will have guaranteed + // hasSameType, so we can skip further checks. + const auto *LFT = ltrans->getAs<FunctionType>(); + const auto *RFT = rtrans->getAs<FunctionType>(); + if (!S.getLangOpts().CPlusPlus && LFT && RFT) { + // The invocation of IsFunctionConversion below will try to transform rtrans + // to obtain an exact match for ltrans. This should not fail because of + // mismatches in result type and parameter types, they were already checked + // by typesAreCompatible above. So we will recreate rtrans (or where + // appropriate ltrans) using the result type and parameter types from ltrans + // (respectively rtrans), but keeping its ExtInfo/ExtProtoInfo. + const auto *LFPT = dyn_cast<FunctionProtoType>(LFT); + const auto *RFPT = dyn_cast<FunctionProtoType>(RFT); + if (LFPT && RFPT) { + rtrans = S.Context.getFunctionType(LFPT->getReturnType(), + LFPT->getParamTypes(), + RFPT->getExtProtoInfo()); + } else if (LFPT) { + FunctionProtoType::ExtProtoInfo EPI; + EPI.ExtInfo = RFT->getExtInfo(); + rtrans = S.Context.getFunctionType(LFPT->getReturnType(), + LFPT->getParamTypes(), EPI); + } else if (RFPT) { + // In this case, we want to retain rtrans as a FunctionProtoType, to keep + // all of its ExtProtoInfo. Transform ltrans instead. + FunctionProtoType::ExtProtoInfo EPI; + EPI.ExtInfo = LFT->getExtInfo(); + ltrans = S.Context.getFunctionType(RFPT->getReturnType(), + RFPT->getParamTypes(), EPI); + } else { + rtrans = S.Context.getFunctionNoProtoType(LFT->getReturnType(), + RFT->getExtInfo()); + } + if (!S.Context.hasSameUnqualifiedType(rtrans, ltrans) && + !S.IsFunctionConversion(rtrans, ltrans)) return AssignConvertType::IncompatibleFunctionPointer; } - if (IsInvalidCmseNSCallConversion(S, ltrans, rtrans)) - return AssignConvertType::IncompatibleFunctionPointer; - if (S.IsInvalidSMECallConversion(rtrans, ltrans)) - return AssignConvertType::IncompatibleFunctionPointer; return ConvTy; } diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 09e5d69..17cb1e4 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1240,6 +1240,20 @@ static CXXMethodDecl *lookupMethod(Sema &S, CXXRecordDecl *RecordDecl, } // end anonymous namespace +static bool hasCounterHandle(const CXXRecordDecl *RD) { + if (RD->field_empty()) + return false; + auto It = std::next(RD->field_begin()); + if (It == RD->field_end()) + return false; + const FieldDecl *SecondField = *It; + if (const auto *ResTy = + SecondField->getType()->getAs<HLSLAttributedResourceType>()) { + return ResTy->getAttrs().IsCounter; + } + return false; +} + bool SemaHLSL::handleRootSignatureElements( ArrayRef<hlsl::RootSignatureElement> Elements) { // Define some common error handling functions @@ -2973,6 +2987,25 @@ bool SemaHLSL::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { TheCall->setType(ResourceTy); break; } + case Builtin::BI__builtin_hlsl_resource_counterhandlefromimplicitbinding: { + ASTContext &AST = SemaRef.getASTContext(); + if (SemaRef.checkArgCount(TheCall, 3) || + CheckResourceHandle(&SemaRef, TheCall, 0) || + CheckArgTypeMatches(&SemaRef, TheCall->getArg(1), AST.UnsignedIntTy) || + CheckArgTypeMatches(&SemaRef, TheCall->getArg(2), AST.UnsignedIntTy)) + return true; + + QualType MainHandleTy = TheCall->getArg(0)->getType(); + auto *MainResType = MainHandleTy->getAs<HLSLAttributedResourceType>(); + auto MainAttrs = MainResType->getAttrs(); + assert(!MainAttrs.IsCounter && "cannot create a counter from a counter"); + MainAttrs.IsCounter = true; + QualType CounterHandleTy = AST.getHLSLAttributedResourceType( + MainResType->getWrappedType(), MainResType->getContainedType(), + MainAttrs); + TheCall->setType(CounterHandleTy); + break; + } case Builtin::BI__builtin_hlsl_and: case Builtin::BI__builtin_hlsl_or: { if (SemaRef.checkArgCount(TheCall, 2)) @@ -3780,10 +3813,24 @@ void SemaHLSL::ActOnVariableDeclarator(VarDecl *VD) { uint32_t OrderID = getNextImplicitBindingOrderID(); if (Binding.hasBinding()) Binding.setImplicitOrderID(OrderID); - else + else { addImplicitBindingAttrToDecl( SemaRef, VD, getRegisterType(getResourceArrayHandleType(VD)), OrderID); + // Re-create the binding object to pick up the new attribute. + Binding = ResourceBindingAttrs(VD); + } + } + + // Get to the base type of a potentially multi-dimensional array. + QualType Ty = getASTContext().getBaseElementType(VD->getType()); + + const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); + if (hasCounterHandle(RD)) { + if (!Binding.hasCounterImplicitOrderID()) { + uint32_t OrderID = getNextImplicitBindingOrderID(); + Binding.setCounterImplicitOrderID(OrderID); + } } } } @@ -3808,19 +3855,31 @@ bool SemaHLSL::initGlobalResourceDecl(VarDecl *VD) { CXXMethodDecl *CreateMethod = nullptr; llvm::SmallVector<Expr *> Args; + bool HasCounter = hasCounterHandle(ResourceDecl); + const char *CreateMethodName; + if (Binding.isExplicit()) + CreateMethodName = HasCounter ? "__createFromBindingWithImplicitCounter" + : "__createFromBinding"; + else + CreateMethodName = HasCounter + ? "__createFromImplicitBindingWithImplicitCounter" + : "__createFromImplicitBinding"; + + CreateMethod = + lookupMethod(SemaRef, ResourceDecl, CreateMethodName, VD->getLocation()); + + if (!CreateMethod) + // This can happen if someone creates a struct that looks like an HLSL + // resource record but does not have the required static create method. + // No binding will be generated for it. + return false; + if (Binding.isExplicit()) { - // The resource has explicit binding. - CreateMethod = lookupMethod(SemaRef, ResourceDecl, "__createFromBinding", - VD->getLocation()); IntegerLiteral *RegSlot = IntegerLiteral::Create(AST, llvm::APInt(UIntTySize, Binding.getSlot()), AST.UnsignedIntTy, SourceLocation()); Args.push_back(RegSlot); } else { - // The resource has implicit binding. - CreateMethod = - lookupMethod(SemaRef, ResourceDecl, "__createFromImplicitBinding", - VD->getLocation()); uint32_t OrderID = (Binding.hasImplicitOrderID()) ? Binding.getImplicitOrderID() : getNextImplicitBindingOrderID(); @@ -3830,12 +3889,6 @@ bool SemaHLSL::initGlobalResourceDecl(VarDecl *VD) { Args.push_back(OrderId); } - if (!CreateMethod) - // This can happen if someone creates a struct that looks like an HLSL - // resource record but does not have the required static create method. - // No binding will be generated for it. - return false; - IntegerLiteral *Space = IntegerLiteral::Create(AST, llvm::APInt(UIntTySize, Binding.getSpace()), AST.UnsignedIntTy, SourceLocation()); @@ -3859,6 +3912,15 @@ bool SemaHLSL::initGlobalResourceDecl(VarDecl *VD) { Name, nullptr, VK_PRValue, FPOptionsOverride()); Args.push_back(NameCast); + if (HasCounter) { + // Will this be in the correct order? + uint32_t CounterOrderID = getNextImplicitBindingOrderID(); + IntegerLiteral *CounterId = + IntegerLiteral::Create(AST, llvm::APInt(UIntTySize, CounterOrderID), + AST.UnsignedIntTy, SourceLocation()); + Args.push_back(CounterId); + } + // Make sure the create method template is instantiated and emitted. if (!CreateMethod->isDefined() && CreateMethod->isTemplateInstantiation()) SemaRef.InstantiateFunctionDefinition(VD->getLocation(), CreateMethod, @@ -3899,20 +3961,24 @@ bool SemaHLSL::initGlobalResourceArrayDecl(VarDecl *VD) { ASTContext &AST = SemaRef.getASTContext(); QualType ResElementTy = AST.getBaseElementType(VD->getType()); CXXRecordDecl *ResourceDecl = ResElementTy->getAsCXXRecordDecl(); - - HLSLResourceBindingAttr *RBA = VD->getAttr<HLSLResourceBindingAttr>(); - HLSLVkBindingAttr *VkBinding = VD->getAttr<HLSLVkBindingAttr>(); CXXMethodDecl *CreateMethod = nullptr; - if (VkBinding || (RBA && RBA->hasRegisterSlot())) + bool HasCounter = hasCounterHandle(ResourceDecl); + ResourceBindingAttrs ResourceAttrs(VD); + if (ResourceAttrs.isExplicit()) // Resource has explicit binding. - CreateMethod = lookupMethod(SemaRef, ResourceDecl, "__createFromBinding", - VD->getLocation()); - else - // Resource has implicit binding. CreateMethod = - lookupMethod(SemaRef, ResourceDecl, "__createFromImplicitBinding", + lookupMethod(SemaRef, ResourceDecl, + HasCounter ? "__createFromBindingWithImplicitCounter" + : "__createFromBinding", VD->getLocation()); + else + // Resource has implicit binding. + CreateMethod = lookupMethod( + SemaRef, ResourceDecl, + HasCounter ? "__createFromImplicitBindingWithImplicitCounter" + : "__createFromImplicitBinding", + VD->getLocation()); if (!CreateMethod) return false; diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp index 8471f02..4824b5a 100644 --- a/clang/lib/Sema/SemaOpenACC.cpp +++ b/clang/lib/Sema/SemaOpenACC.cpp @@ -2946,5 +2946,5 @@ OpenACCReductionRecipe SemaOpenACC::CreateReductionInitRecipe( AllocaDecl->setInit(Init.get()); AllocaDecl->setInitStyle(VarDecl::CallInit); } - return OpenACCReductionRecipe(AllocaDecl); + return OpenACCReductionRecipe(AllocaDecl, {}); } diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 8d32ef6..8339bb1 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -1892,14 +1892,7 @@ bool Sema::TryFunctionConversion(QualType FromType, QualType ToType, return Changed; } -bool Sema::IsFunctionConversion(QualType FromType, QualType ToType, - bool *DiscardingCFIUncheckedCallee, - bool *AddingCFIUncheckedCallee) const { - if (DiscardingCFIUncheckedCallee) - *DiscardingCFIUncheckedCallee = false; - if (AddingCFIUncheckedCallee) - *AddingCFIUncheckedCallee = false; - +bool Sema::IsFunctionConversion(QualType FromType, QualType ToType) const { if (Context.hasSameUnqualifiedType(FromType, ToType)) return false; @@ -1958,25 +1951,14 @@ bool Sema::IsFunctionConversion(QualType FromType, QualType ToType, const auto *ToFPT = dyn_cast<FunctionProtoType>(ToFn); if (FromFPT && ToFPT) { - if (FromFPT->hasCFIUncheckedCallee() && !ToFPT->hasCFIUncheckedCallee()) { - QualType NewTy = Context.getFunctionType( - FromFPT->getReturnType(), FromFPT->getParamTypes(), - FromFPT->getExtProtoInfo().withCFIUncheckedCallee(false)); - FromFPT = cast<FunctionProtoType>(NewTy.getTypePtr()); - FromFn = FromFPT; - Changed = true; - if (DiscardingCFIUncheckedCallee) - *DiscardingCFIUncheckedCallee = true; - } else if (!FromFPT->hasCFIUncheckedCallee() && - ToFPT->hasCFIUncheckedCallee()) { + if (FromFPT->hasCFIUncheckedCallee() != ToFPT->hasCFIUncheckedCallee()) { QualType NewTy = Context.getFunctionType( FromFPT->getReturnType(), FromFPT->getParamTypes(), - FromFPT->getExtProtoInfo().withCFIUncheckedCallee(true)); + FromFPT->getExtProtoInfo().withCFIUncheckedCallee( + ToFPT->hasCFIUncheckedCallee())); FromFPT = cast<FunctionProtoType>(NewTy.getTypePtr()); FromFn = FromFPT; Changed = true; - if (AddingCFIUncheckedCallee) - *AddingCFIUncheckedCallee = true; } } @@ -2007,11 +1989,7 @@ bool Sema::IsFunctionConversion(QualType FromType, QualType ToType, Changed = true; } - // For C, when called from checkPointerTypesForAssignment, - // we need to not alter FromFn, or else even an innocuous cast - // like dropping effects will fail. In C++ however we do want to - // alter FromFn (because of the way PerformImplicitConversion works). - if (Context.hasAnyFunctionEffects() && getLangOpts().CPlusPlus) { + if (Context.hasAnyFunctionEffects()) { FromFPT = cast<FunctionProtoType>(FromFn); // in case FromFn changed above // Transparently add/drop effects; here we are concerned with diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 419f3e1..3a6ff99 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -318,7 +318,7 @@ TemplateNameKind Sema::isTemplateName(Scope *S, } } - if (isPackProducingBuiltinTemplateName(Template) && + if (isPackProducingBuiltinTemplateName(Template) && S && S->getTemplateParamParent() == nullptr) Diag(Name.getBeginLoc(), diag::err_builtin_pack_outside_template) << TName; // Recover by returning the template, even though we would never be able to diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index 51b55b8..940324b 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -16364,16 +16364,21 @@ ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( AssociatedDecl == E->getAssociatedDecl()) return E; + auto getParamAndType = [Index = E->getIndex()](Decl *AssociatedDecl) + -> std::tuple<NonTypeTemplateParmDecl *, QualType> { + auto [PDecl, Arg] = getReplacedTemplateParameter(AssociatedDecl, Index); + auto *Param = cast<NonTypeTemplateParmDecl>(PDecl); + return {Param, Arg.isNull() ? Param->getType() + : Arg.getNonTypeTemplateArgumentType()}; + }; + // If the replacement expression did not change, and the parameter type // did not change, we can skip the semantic action because it would // produce the same result anyway. - auto *Param = cast<NonTypeTemplateParmDecl>( - getReplacedTemplateParameterList(AssociatedDecl) - ->asArray()[E->getIndex()]); - if (QualType ParamType = Param->getType(); - !SemaRef.Context.hasSameType(ParamType, E->getParameter()->getType()) || + if (auto [Param, ParamType] = getParamAndType(AssociatedDecl); + !SemaRef.Context.hasSameType( + ParamType, std::get<1>(getParamAndType(E->getAssociatedDecl()))) || Replacement.get() != OrigReplacement) { - // When transforming the replacement expression previously, all Sema // specific annotations, such as implicit casts, are discarded. Calling the // corresponding sema action is necessary to recover those. Otherwise, diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 6acf79a..868f0cc 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -13009,9 +13009,22 @@ OpenACCClause *ASTRecordReader::readOpenACCClause() { llvm::SmallVector<OpenACCReductionRecipe> RecipeList; for (unsigned I = 0; I < VarList.size(); ++I) { - static_assert(sizeof(OpenACCReductionRecipe) == sizeof(int *)); VarDecl *Recipe = readDeclAs<VarDecl>(); - RecipeList.push_back({Recipe}); + + static_assert(sizeof(OpenACCReductionRecipe::CombinerRecipe) == + 3 * sizeof(int *)); + + llvm::SmallVector<OpenACCReductionRecipe::CombinerRecipe> Combiners; + unsigned NumCombiners = readInt(); + for (unsigned I = 0; I < NumCombiners; ++I) { + VarDecl *LHS = readDeclAs<VarDecl>(); + VarDecl *RHS = readDeclAs<VarDecl>(); + Expr *Op = readExpr(); + + Combiners.push_back({LHS, RHS, Op}); + } + + RecipeList.push_back({Recipe, Combiners}); } return OpenACCReductionClause::Create(getContext(), BeginLoc, LParenLoc, Op, diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 09b1e58..82ccde8 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -8925,8 +8925,17 @@ void ASTRecordWriter::writeOpenACCClause(const OpenACCClause *C) { writeOpenACCVarList(RC); for (const OpenACCReductionRecipe &R : RC->getRecipes()) { - static_assert(sizeof(OpenACCReductionRecipe) == 1 * sizeof(int *)); AddDeclRef(R.AllocaDecl); + + static_assert(sizeof(OpenACCReductionRecipe::CombinerRecipe) == + 3 * sizeof(int *)); + writeUInt32(R.CombinerRecipes.size()); + + for (auto &CombinerRecipe : R.CombinerRecipes) { + AddDeclRef(CombinerRecipe.LHS); + AddDeclRef(CombinerRecipe.RHS); + AddStmt(CombinerRecipe.Op); + } } return; } diff --git a/clang/lib/StaticAnalyzer/Checkers/VAListChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/VAListChecker.cpp index 79fd0bd..503fa5d 100644 --- a/clang/lib/StaticAnalyzer/Checkers/VAListChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/VAListChecker.cpp @@ -149,7 +149,7 @@ void VAListChecker::checkPreCall(const CallEvent &Call, else if (VaEnd.matches(Call)) checkVAListEndCall(Call, C); else { - for (auto FuncInfo : VAListAccepters) { + for (const auto &FuncInfo : VAListAccepters) { if (!FuncInfo.Func.matches(Call)) continue; const MemRegion *VAList = diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp index 15a0c5a..ace639c 100644 --- a/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/RawPtrRefMemberChecker.cpp @@ -232,7 +232,7 @@ public: bool ignoreARC = !PD->isReadOnly() && PD->getSetterKind() == ObjCPropertyDecl::Assign; auto IsUnsafePtr = isUnsafePtr(QT, ignoreARC); - return {IsUnsafePtr && *IsUnsafePtr, PropType}; + return {IsUnsafePtr && *IsUnsafePtr && !PD->isRetaining(), PropType}; } bool shouldSkipDecl(const RecordDecl *RD) const { diff --git a/clang/test/AST/ByteCode/libcxx/deref-to-array.cpp b/clang/test/AST/ByteCode/libcxx/deref-to-array.cpp index 2a527ab..7cfcd76 100644 --- a/clang/test/AST/ByteCode/libcxx/deref-to-array.cpp +++ b/clang/test/AST/ByteCode/libcxx/deref-to-array.cpp @@ -270,7 +270,7 @@ template <class _Op, class _Yp> void __is_derived_from_view_interface(); template <class _Tp> bool enable_view = derived_from<_Tp, int> || - requires { ranges::__is_derived_from_view_interface; }; + requires { ranges::__is_derived_from_view_interface<_Tp, int>(); }; template <class> concept range = requires { ranges::end; }; template <class _Tp> diff --git a/clang/test/AST/HLSL/StructuredBuffers-AST.hlsl b/clang/test/AST/HLSL/StructuredBuffers-AST.hlsl index 6779abb..e72207e 100644 --- a/clang/test/AST/HLSL/StructuredBuffers-AST.hlsl +++ b/clang/test/AST/HLSL/StructuredBuffers-AST.hlsl @@ -4,7 +4,7 @@ // // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-library -x hlsl -ast-dump \ // RUN: -DRESOURCE=StructuredBuffer %s | FileCheck -DRESOURCE=StructuredBuffer \ -// RUN: -check-prefixes=CHECK,CHECK-SRV,CHECK-SUBSCRIPT,CHECK-LOAD %s +// RUN: -check-prefixes=CHECK,CHECK-SRV,CHECK-SUBSCRIPT,CHECK-LOAD,CHECK-BINDING %s // // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-library -x hlsl -ast-dump -DEMPTY \ // RUN: -DRESOURCE=RWStructuredBuffer %s | FileCheck -DRESOURCE=RWStructuredBuffer \ @@ -141,59 +141,133 @@ RESOURCE<float> Buffer; // Static __createFromBinding method -// CHECK: CXXMethodDecl {{.*}} __createFromBinding 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *)' static -// CHECK-NEXT: ParmVarDecl {{.*}} registerNo 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} range 'int' -// CHECK-NEXT: ParmVarDecl {{.*}} index 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} name 'const char *' -// CHECK-NEXT: CompoundStmt -// CHECK-NEXT: DeclStmt -// CHECK-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' -// CHECK-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' -// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> -// CHECK-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefrombinding' 'void (...) noexcept' -// CHECK-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'registerNo' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' -// CHECK-NEXT: ReturnStmt -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline +// CHECK-BINDING: CXXMethodDecl {{.*}} __createFromBinding 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *)' static +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} registerNo 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} range 'int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} index 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} name 'const char *' +// CHECK-BINDING-NEXT: CompoundStmt +// CHECK-BINDING-NEXT: DeclStmt +// CHECK-BINDING-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-BINDING-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-BINDING-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefrombinding' 'void (...) noexcept' +// CHECK-BINDING-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'registerNo' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' +// CHECK-BINDING-NEXT: ReturnStmt +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline // Static __createFromImplicitBinding method -// CHECK: CXXMethodDecl {{.*}} __createFromImplicitBinding 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *)' static -// CHECK-NEXT: ParmVarDecl {{.*}} orderId 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} range 'int' -// CHECK-NEXT: ParmVarDecl {{.*}} index 'unsigned int' -// CHECK-NEXT: ParmVarDecl {{.*}} name 'const char *' -// CHECK-NEXT: CompoundStmt {{.*}} -// CHECK-NEXT: DeclStmt {{.*}} -// CHECK-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' -// CHECK-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' -// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> -// CHECK-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefromimplicitbinding' 'void (...) noexcept' -// CHECK-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'orderId' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' -// CHECK-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' -// CHECK-NEXT: ReturnStmt -// CHECK-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' -// CHECK-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline +// CHECK-BINDING: CXXMethodDecl {{.*}} __createFromImplicitBinding 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *)' static +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} orderId 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} range 'int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} index 'unsigned int' +// CHECK-BINDING-NEXT: ParmVarDecl {{.*}} name 'const char *' +// CHECK-BINDING-NEXT: CompoundStmt {{.*}} +// CHECK-BINDING-NEXT: DeclStmt {{.*}} +// CHECK-BINDING-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-BINDING-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-BINDING-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefromimplicitbinding' 'void (...) noexcept' +// CHECK-BINDING-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'orderId' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' +// CHECK-BINDING-NEXT: ReturnStmt +// CHECK-BINDING-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-BINDING-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline + +// CHECK-COUNTER-HANDLE: CXXMethodDecl {{.*}} __createFromBindingWithImplicitCounter 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' static +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} registerNo 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} range 'int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} index 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} name 'const char *' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} counterOrderId 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: CompoundStmt +// CHECK-COUNTER-HANDLE-NEXT: DeclStmt +// CHECK-COUNTER-HANDLE-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-COUNTER-HANDLE-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefrombinding' 'void (...) noexcept' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'registerNo' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' +// CHECK-COUNTER-HANDLE-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__counter_handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-COUNTER-HANDLE-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_counterhandlefromimplicitbinding' 'void (...) noexcept' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'counterOrderId' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ReturnStmt +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline + +// CHECK-COUNTER-HANDLE: CXXMethodDecl {{.*}} __createFromImplicitBindingWithImplicitCounter 'hlsl::[[RESOURCE]]<element_type> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' static +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} orderId 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} spaceNo 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} range 'int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} index 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} name 'const char *' +// CHECK-COUNTER-HANDLE-NEXT: ParmVarDecl {{.*}} counterOrderId 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: CompoundStmt +// CHECK-COUNTER-HANDLE-NEXT: DeclStmt +// CHECK-COUNTER-HANDLE-NEXT: VarDecl {{.*}} tmp 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-COUNTER-HANDLE-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_handlefromimplicitbinding' 'void (...) noexcept' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'orderId' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'int' ParmVar {{.*}} 'range' 'int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'index' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'const char *' ParmVar {{.*}} 'name' 'const char *' +// CHECK-COUNTER-HANDLE-NEXT: BinaryOperator {{.*}} '__hlsl_resource_t {{.*}}]]' '=' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__counter_handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: CallExpr {{.*}} '__hlsl_resource_t {{.*}}' +// CHECK-COUNTER-HANDLE-NEXT: ImplicitCastExpr {{.*}} 'void (*)(...) noexcept' <BuiltinFnToFnPtr> +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} '<builtin fn type>' Function {{.*}} '__builtin_hlsl_resource_counterhandlefromimplicitbinding' 'void (...) noexcept' +// CHECK-COUNTER-HANDLE-NEXT: MemberExpr {{.*}} '__hlsl_resource_t {{.*}}' lvalue .__handle +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'counterOrderId' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'unsigned int' ParmVar {{.*}} 'spaceNo' 'unsigned int' +// CHECK-COUNTER-HANDLE-NEXT: ReturnStmt +// CHECK-COUNTER-HANDLE-NEXT: DeclRefExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue Var {{.*}} 'tmp' 'hlsl::[[RESOURCE]]<element_type>' +// CHECK-COUNTER-HANDLE-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline // Subscript operators @@ -263,7 +337,7 @@ RESOURCE<float> Buffer; // CHECK-COUNTER-NEXT: MemberExpr {{.*}} '__hlsl_resource_t // CHECK-COUNTER-SAME{LITERAL}: [[hlsl::resource_class(UAV)]] // CHECK-COUNTER-SAME{LITERAL}: [[hlsl::raw_buffer]] -// CHECK-COUNTER-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__handle +// CHECK-COUNTER-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__counter_handle // CHECK-COUNTER-NEXT: CXXThisExpr {{.*}} 'hlsl::RWStructuredBuffer<element_type>' lvalue implicit this // CHECK-COUNTER-NEXT: IntegerLiteral {{.*}} 'int' 1 // CHECK-COUNTER-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline @@ -279,7 +353,7 @@ RESOURCE<float> Buffer; // CHECK-COUNTER-NEXT: MemberExpr {{.*}} '__hlsl_resource_t // CHECK-COUNTER-SAME{LITERAL}: [[hlsl::resource_class(UAV)]] // CHECK-COUNTER-SAME{LITERAL}: [[hlsl::raw_buffer]] -// CHECK-COUNTER-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__handle +// CHECK-COUNTER-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__counter_handle // CHECK-COUNTER-NEXT: CXXThisExpr {{.*}} 'hlsl::RWStructuredBuffer<element_type>' lvalue implicit this // CHECK-COUNTER-NEXT: IntegerLiteral {{.*}} 'int' -1 // CHECK-COUNTER-NEXT: AlwaysInlineAttr {{.*}} Implicit always_inline @@ -305,7 +379,7 @@ RESOURCE<float> Buffer; // CHECK-APPEND-NEXT: MemberExpr {{.*}} '__hlsl_resource_t // CHECK-APPEND-SAME{LITERAL}: [[hlsl::resource_class(UAV)]] // CHECK-APPEND-SAME{LITERAL}: [[hlsl::raw_buffer]] -// CHECK-APPEND-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__handle +// CHECK-APPEND-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__counter_handle // CHECK-APPEND-NEXT: CXXThisExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue implicit this // CHECK-APPEND-NEXT: IntegerLiteral {{.*}} 'int' 1 // CHECK-APPEND-NEXT: DeclRefExpr {{.*}} 'element_type' ParmVar {{.*}} 'value' 'element_type' @@ -330,7 +404,7 @@ RESOURCE<float> Buffer; // CHECK-CONSUME-NEXT: MemberExpr {{.*}} '__hlsl_resource_t // CHECK-CONSUME-SAME{LITERAL}: [[hlsl::resource_class(UAV)]] // CHECK-CONSUME-SAME{LITERAL}: [[hlsl::raw_buffer]] -// CHECK-CONSUME-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__handle +// CHECK-CONSUME-SAME{LITERAL}: [[hlsl::contained_type(element_type)]]' lvalue .__counter_handle // CHECK-CONSUME-NEXT: CXXThisExpr {{.*}} 'hlsl::[[RESOURCE]]<element_type>' lvalue implicit this // CHECK-CONSUME-NEXT: IntegerLiteral {{.*}} 'int' -1 diff --git a/clang/test/AST/HLSL/vk_binding_attr.hlsl b/clang/test/AST/HLSL/vk_binding_attr.hlsl index 13e7544..da5a42c 100644 --- a/clang/test/AST/HLSL/vk_binding_attr.hlsl +++ b/clang/test/AST/HLSL/vk_binding_attr.hlsl @@ -76,13 +76,13 @@ // CHECK: VarDecl {{.*}} Buf6 'RWStructuredBuffer<int>':'hlsl::RWStructuredBuffer<int>' // CHECK-NEXT: CallExpr {{.*}} 'RWStructuredBuffer<int>':'hlsl::RWStructuredBuffer<int>' -// CHECK-NEXT: ImplicitCastExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (*)(unsigned int, unsigned int, int, unsigned int, const char *)' <FunctionToPointerDecay> -// SPV-NEXT: DeclRefExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' -// SPV-NEXT-SAME: CXXMethod {{.*}} '__createFromBinding' 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' +// CHECK-NEXT: ImplicitCastExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (*)(unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' <FunctionToPointerDecay> +// SPV-NEXT: DeclRefExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' +// SPV-NEXT-SAME: CXXMethod {{.*}} '__createFromBindingwithImplicitCounter' 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 26 // SPV-NEXT: IntegerLiteral {{.*}} 'unsigned int' 105 -// DXIL-NEXT: DeclRefExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' -// DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromBinding' 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *)' +// DXIL-NEXT: DeclRefExpr {{.*}} 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' +// DXIL-NEXT-SAME: CXXMethod {{.*}} '__createFromImplicitBindingwithImplicitCounter' 'hlsl::RWStructuredBuffer<int> (unsigned int, unsigned int, int, unsigned int, const char *, unsigned int)' // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 4 // DXIL-NEXT: IntegerLiteral {{.*}} 'unsigned int' 0 // CHECK: HLSLVkBindingAttr {{.*}} 26 105 diff --git a/clang/test/Analysis/Checkers/WebKit/unretained-members.mm b/clang/test/Analysis/Checkers/WebKit/unretained-members.mm index adf1d8a..2b120b9 100644 --- a/clang/test/Analysis/Checkers/WebKit/unretained-members.mm +++ b/clang/test/Analysis/Checkers/WebKit/unretained-members.mm @@ -113,7 +113,6 @@ namespace ptr_to_ptr_to_retained { // expected-warning@-1{{Instance variable 'dispatch' in 'AnotherObject' is a retainable type 'dispatch_queue_t'}} } @property(nonatomic, readonly, strong) NSString *prop_string; -// expected-warning@-1{{Property 'prop_string' in 'AnotherObject' is a raw pointer to retainable type 'NSString'; member variables must be a RetainPtr}} @property(nonatomic, readonly) NSString *prop_safe; @end @@ -132,7 +131,6 @@ namespace ptr_to_ptr_to_retained { // expected-warning@-1{{Instance variable 'os_dispatch' in 'DerivedObject' is a retainable type 'dispatch_queue_t'}} } @property(nonatomic, strong) NSNumber *prop_number; -// expected-warning@-1{{Property 'prop_number' in 'DerivedObject' is a raw pointer to retainable type 'NSNumber'; member variables must be a RetainPtr}} @property(nonatomic, readonly) NSString *prop_string; @end @@ -178,12 +176,12 @@ NS_REQUIRES_PROPERTY_DEFINITIONS } @property(nonatomic, readonly, strong) NSString *prop_string1; @property(nonatomic, readonly, strong) NSString *prop_string2; -// expected-warning@-1{{Property 'prop_string2' in 'NoSynthObject' is a raw pointer to retainable type 'NSString'}} @property(nonatomic, assign) NSString *prop_string3; // expected-warning@-1{{Property 'prop_string3' in 'NoSynthObject' is a raw pointer to retainable type 'NSString'; member variables must be a RetainPtr}} @property(nonatomic, unsafe_unretained) NSString *prop_string4; // expected-warning@-1{{Property 'prop_string4' in 'NoSynthObject' is a raw pointer to retainable type 'NSString'; member variables must be a RetainPtr}} -@property(nonatomic, readonly, strong) NSString *dispatch; +@property(nonatomic, copy) NSString *prop_string5; +@property(nonatomic, readonly, strong) dispatch_queue_t dispatch; @end @implementation NoSynthObject @@ -193,6 +191,7 @@ NS_REQUIRES_PROPERTY_DEFINITIONS @synthesize prop_string2; @synthesize prop_string3; @synthesize prop_string4; +@synthesize prop_string5; - (dispatch_queue_t)dispatch { return nil; } 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/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp index 66554b7..7fb0975 100644 --- a/clang/test/CIR/CodeGen/dtors.cpp +++ b/clang/test/CIR/CodeGen/dtors.cpp @@ -171,3 +171,121 @@ 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]]) + +struct E { + ~E(); +}; + +struct F : public E { + int n; + ~F() {} +}; + +// CIR: cir.func {{.*}} @_ZN1FD2Ev +// CIR: %[[BASE_E:.*]] = cir.base_class_addr %{{.*}} : !cir.ptr<!rec_F> nonnull [0] -> !cir.ptr<!rec_E> +// CIR: cir.call @_ZN1ED2Ev(%[[BASE_E]]) nothrow : (!cir.ptr<!rec_E>) -> () + +// Because E is at offset 0 in F, there is no getelementptr needed. + +// LLVM: define {{.*}} void @_ZN1FD2Ev +// LLVM: call void @_ZN1ED2Ev(ptr %{{.*}}) + +// This destructor is defined after the calling function in OGCG. + +void test_base_dtor_call() { + F f; +} + +// CIR: cir.func {{.*}} @_Z19test_base_dtor_callv() +// cir.call @_ZN1FD2Ev(%{{.*}}) nothrow : (!cir.ptr<!rec_F>) -> () + +// LLVM: define {{.*}} void @_Z19test_base_dtor_callv() +// LLVM: call void @_ZN1FD2Ev(ptr %{{.*}}) + +// OGCG: define {{.*}} void @_Z19test_base_dtor_callv() +// OGCG: call void @_ZN1FD2Ev(ptr {{.*}} %{{.*}}) + +// OGCG: define {{.*}} void @_ZN1FD2Ev +// OGCG: call void @_ZN1ED2Ev(ptr {{.*}} %{{.*}}) + +struct VirtualBase { + ~VirtualBase(); +}; + +struct Derived : virtual VirtualBase { + ~Derived() {} +}; + +void test_base_dtor_call_virtual_base() { + Derived d; +} + +// Derived D2 (base) destructor -- does not call VirtualBase destructor + +// CIR: cir.func {{.*}} @_ZN7DerivedD2Ev +// CIR-NOT: cir.call{{.*}} @_ZN11VirtualBaseD2Ev +// CIR: cir.return + +// LLVM: define {{.*}} void @_ZN7DerivedD2Ev +// LLVM-NOT: call{{.*}} @_ZN11VirtualBaseD2Ev +// LLVM: ret + +// Derived D1 (complete) destructor -- does call VirtualBase destructor + +// CIR: cir.func {{.*}} @_ZN7DerivedD1Ev +// CIR: %[[THIS:.*]] = cir.load %{{.*}} +// CIR: %[[VTT:.*]] = cir.vtt.address_point @_ZTT7Derived, offset = 0 -> !cir.ptr<!cir.ptr<!void>> +// CIR: cir.call @_ZN7DerivedD2Ev(%[[THIS]], %[[VTT]]) +// CIR: %[[VIRTUAL_BASE:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_VirtualBase> +// CIR: cir.call @_ZN11VirtualBaseD2Ev(%[[VIRTUAL_BASE]]) + +// LLVM: define {{.*}} void @_ZN7DerivedD1Ev +// LLVM: call void @_ZN7DerivedD2Ev(ptr %{{.*}}, ptr @_ZTT7Derived) +// LLVM: call void @_ZN11VirtualBaseD2Ev(ptr %{{.*}}) + +// OGCG emits these destructors in reverse order + +// OGCG: define {{.*}} void @_ZN7DerivedD1Ev +// OGCG: call void @_ZN7DerivedD2Ev(ptr {{.*}} %{{.*}}, ptr {{.*}} @_ZTT7Derived) +// OGCG: call void @_ZN11VirtualBaseD2Ev(ptr {{.*}} %{{.*}}) + +// OGCG: define {{.*}} void @_ZN7DerivedD2Ev +// OGCG-NOT: call{{.*}} @_ZN11VirtualBaseD2Ev +// OGCG: ret diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp new file mode 100644 index 0000000..e5244b2 --- /dev/null +++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fclangir -emit-cir -mmlir --mlir-print-ir-before=cir-lowering-prepare %s -o %t.cir 2> %t.before.log +// RUN: FileCheck %s --input-file=%t.before.log -check-prefix=CIR-BEFORE + +struct Base { + virtual ~Base(); +}; + +struct Derived : Base {}; + +// CIR-BEFORE-DAG: !rec_Base = !cir.record +// CIR-BEFORE-DAG: !rec_Derived = !cir.record +// CIR-BEFORE-DAG: #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> + +Derived *ptr_cast(Base *b) { + return dynamic_cast<Derived *>(b); +} + +// CIR-BEFORE: cir.func dso_local @_Z8ptr_castP4Base +// CIR-BEFORE: %{{.+}} = cir.dyn_cast ptr %{{.+}} : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived +// CIR-BEFORE: } + +Derived &ref_cast(Base &b) { + return dynamic_cast<Derived &>(b); +} + +// CIR-BEFORE: cir.func dso_local @_Z8ref_castR4Base +// CIR-BEFORE: %{{.+}} = cir.dyn_cast ref %{{.+}} : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived +// CIR-BEFORE: } diff --git a/clang/test/CIR/CodeGen/global-init.cpp b/clang/test/CIR/CodeGen/global-init.cpp index 0c19e68..0aab695 100644 --- a/clang/test/CIR/CodeGen/global-init.cpp +++ b/clang/test/CIR/CodeGen/global-init.cpp @@ -1,9 +1,27 @@ // 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 +// 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 -// Note: The LoweringPrepare work isn't yet complete. We still need to create -// the global ctor list attribute. +// Declarations that appear before global-specific definitions + +// CIR: module @{{.*}} attributes { +// CIR-SAME: cir.global_ctors = [#cir.global_ctor<"_GLOBAL__sub_I_[[FILENAME:.*]]", 65535>] + +// LLVM: @__dso_handle = external hidden global i8 +// LLVM: @needsCtor = global %struct.NeedsCtor zeroinitializer, align 1 +// LLVM: @needsDtor = global %struct.NeedsDtor zeroinitializer, align 1 +// LLVM: @needsCtorDtor = global %struct.NeedsCtorDtor 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 }] + +// OGCG: @needsCtor = global %struct.NeedsCtor zeroinitializer, align 1 +// OGCG: @needsDtor = global %struct.NeedsDtor zeroinitializer, align 1 +// OGCG: @__dso_handle = external hidden global i8 +// OGCG: @needsCtorDtor = global %struct.NeedsCtorDtor 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 }] struct NeedsCtor { NeedsCtor(); @@ -20,7 +38,84 @@ NeedsCtor needsCtor; // CIR: %0 = cir.get_global @needsCtor : !cir.ptr<!rec_NeedsCtor> // CIR: cir.call @_ZN9NeedsCtorC1Ev(%0) : (!cir.ptr<!rec_NeedsCtor>) -> () +// LLVM: define internal void @__cxx_global_var_init() +// LLVM: call void @_ZN9NeedsCtorC1Ev(ptr @needsCtor) + +// OGCG: define internal void @__cxx_global_var_init() {{.*}} section ".text.startup" { +// OGCG: call void @_ZN9NeedsCtorC1Ev(ptr noundef nonnull align 1 dereferenceable(1) @needsCtor) + + +struct NeedsDtor { + ~NeedsDtor(); +}; + +NeedsDtor needsDtor; + +// CIR-BEFORE-LPP: cir.global external @needsDtor = #cir.zero : !rec_NeedsDtor dtor { +// CIR-BEFORE-LPP: %[[THIS:.*]] = cir.get_global @needsDtor : !cir.ptr<!rec_NeedsDtor> +// CIR-BEFORE-LPP: cir.call @_ZN9NeedsDtorD1Ev(%[[THIS]]) : (!cir.ptr<!rec_NeedsDtor>) -> () + +// CIR: cir.global external @needsDtor = #cir.zero : !rec_NeedsDtor +// CIR: cir.func internal private @__cxx_global_var_init.1() { +// CIR: %[[OBJ:.*]] = cir.get_global @needsDtor : !cir.ptr<!rec_NeedsDtor> +// CIR: %[[DTOR:.*]] = cir.get_global @_ZN9NeedsDtorD1Ev : !cir.ptr<!cir.func<(!cir.ptr<!rec_NeedsDtor>)>> +// CIR: %[[DTOR_CAST:.*]] = cir.cast bitcast %[[DTOR]] : !cir.ptr<!cir.func<(!cir.ptr<!rec_NeedsDtor>)>> -> !cir.ptr<!cir.func<(!cir.ptr<!void>)>> +// CIR: %[[OBJ_CAST:.*]] = cir.cast bitcast %[[OBJ]] : !cir.ptr<!rec_NeedsDtor> -> !cir.ptr<!void> +// CIR: %[[HANDLE:.*]] = cir.get_global @__dso_handle : !cir.ptr<i8> +// CIR: cir.call @__cxa_atexit(%[[DTOR_CAST]], %[[OBJ_CAST]], %[[HANDLE]]) : (!cir.ptr<!cir.func<(!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> () + +// LLVM: define internal void @__cxx_global_var_init.1() { +// LLVM: call void @__cxa_atexit(ptr @_ZN9NeedsDtorD1Ev, ptr @needsDtor, ptr @__dso_handle) + +// OGCG: define internal void @__cxx_global_var_init.1() {{.*}} section ".text.startup" { +// OGCG: %{{.*}} = call i32 @__cxa_atexit(ptr @_ZN9NeedsDtorD1Ev, ptr @needsDtor, ptr @__dso_handle) + +struct NeedsCtorDtor { + NeedsCtorDtor(); + ~NeedsCtorDtor(); +}; + +NeedsCtorDtor needsCtorDtor; + +// CIR-BEFORE-LPP: cir.global external @needsCtorDtor = ctor : !rec_NeedsCtorDtor { +// CIR-BEFORE-LPP: %[[THIS:.*]] = cir.get_global @needsCtorDtor : !cir.ptr<!rec_NeedsCtorDtor> +// CIR-BEFORE-LPP: cir.call @_ZN13NeedsCtorDtorC1Ev(%[[THIS]]) : (!cir.ptr<!rec_NeedsCtorDtor>) -> () +// CIR-BEFORE-LPP: } dtor { +// CIR-BEFORE-LPP: %[[THIS:.*]] = cir.get_global @needsCtorDtor : !cir.ptr<!rec_NeedsCtorDtor> +// CIR-BEFORE-LPP: cir.call @_ZN13NeedsCtorDtorD1Ev(%[[THIS]]) : (!cir.ptr<!rec_NeedsCtorDtor>) -> () + +// CIR: cir.global external @needsCtorDtor = #cir.zero : !rec_NeedsCtorDtor +// CIR: cir.func internal private @__cxx_global_var_init.2() { +// CIR: %[[OBJ:.*]] = cir.get_global @needsCtorDtor : !cir.ptr<!rec_NeedsCtorDtor> +// CIR: cir.call @_ZN13NeedsCtorDtorC1Ev(%[[OBJ]]) : (!cir.ptr<!rec_NeedsCtorDtor>) -> () +// CIR: %[[OBJ:.*]] = cir.get_global @needsCtorDtor : !cir.ptr<!rec_NeedsCtorDtor> +// CIR: %[[DTOR:.*]] = cir.get_global @_ZN13NeedsCtorDtorD1Ev : !cir.ptr<!cir.func<(!cir.ptr<!rec_NeedsCtorDtor>)>> +// CIR: %[[DTOR_CAST:.*]] = cir.cast bitcast %[[DTOR]] : !cir.ptr<!cir.func<(!cir.ptr<!rec_NeedsCtorDtor>)>> -> !cir.ptr<!cir.func<(!cir.ptr<!void>)>> +// CIR: %[[OBJ_CAST:.*]] = cir.cast bitcast %[[OBJ]] : !cir.ptr<!rec_NeedsCtorDtor> -> !cir.ptr<!void> +// CIR: %[[HANDLE:.*]] = cir.get_global @__dso_handle : !cir.ptr<i8> +// CIR: cir.call @__cxa_atexit(%[[DTOR_CAST]], %[[OBJ_CAST]], %[[HANDLE]]) : (!cir.ptr<!cir.func<(!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> () + +// LLVM: define internal void @__cxx_global_var_init.2() { +// LLVM: call void @_ZN13NeedsCtorDtorC1Ev(ptr @needsCtorDtor) +// LLVM: call void @__cxa_atexit(ptr @_ZN13NeedsCtorDtorD1Ev, ptr @needsCtorDtor, ptr @__dso_handle) + +// OGCG: define internal void @__cxx_global_var_init.2() {{.*}} section ".text.startup" { +// OGCG: call void @_ZN13NeedsCtorDtorC1Ev(ptr noundef nonnull align 1 dereferenceable(1) @needsCtorDtor) +// OGCG: %{{.*}} = call i32 @__cxa_atexit(ptr @_ZN13NeedsCtorDtorD1Ev, ptr @needsCtorDtor, ptr @__dso_handle) + +// Common init function for all globals with default priority + // CIR: cir.func private @_GLOBAL__sub_I_[[FILENAME:.*]]() { // CIR: cir.call @__cxx_global_var_init() : () -> () -// CIR: cir.return -// CIR: } +// CIR: cir.call @__cxx_global_var_init.1() : () -> () +// CIR: cir.call @__cxx_global_var_init.2() : () -> () + +// LLVM: define void @_GLOBAL__sub_I_[[FILENAME]]() +// LLVM: call void @__cxx_global_var_init() +// LLVM: call void @__cxx_global_var_init.1() +// LLVM: call void @__cxx_global_var_init.2() + +// OGCG: define internal void @_GLOBAL__sub_I_[[FILENAME]]() {{.*}} section ".text.startup" { +// OGCG: call void @__cxx_global_var_init() +// OGCG: call void @__cxx_global_var_init.1() +// OGCG: call void @__cxx_global_var_init.2() diff --git a/clang/test/CIR/CodeGen/record-zero-init-padding.c b/clang/test/CIR/CodeGen/record-zero-init-padding.c new file mode 100644 index 0000000..f131c9b --- /dev/null +++ b/clang/test/CIR/CodeGen/record-zero-init-padding.c @@ -0,0 +1,90 @@ +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir +// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR +// RUN: %clang_cc1 -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 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll +// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG + +struct padding_after_field { + char c; + int i; +}; + +struct bitfield_with_padding { + unsigned int a : 3; + unsigned int b : 5; + int c; +}; + +struct tail_padding { + int a; + char b; +}; + +struct multiple_padding { + char a; + short b; + long long c; +}; + +void test_zero_init_padding(void) { + static const struct padding_after_field paf = {1, 42}; + static const struct bitfield_with_padding bfp = {1, 2, 99}; + static const struct tail_padding tp = {10, 20}; + static const struct multiple_padding mp = {5, 10, 100}; +} + +// Type definitions for anonymous structs with padding +// CIR-DAG: !rec_anon_struct = !cir.record<struct {!s8i, !u8i, !s16i, !cir.array<!u8i x 4>, !s64i}> +// CIR-DAG: !rec_anon_struct1 = !cir.record<struct {!s32i, !s8i, !cir.array<!u8i x 3>}> +// CIR-DAG: !rec_anon_struct2 = !cir.record<struct {!u8i, !cir.array<!u8i x 3>, !s32i}> +// CIR-DAG: !rec_anon_struct3 = !cir.record<struct {!s8i, !cir.array<!u8i x 3>, !s32i}> + +// paf: char + 3 bytes padding + int -> uses !rec_anon_struct3 +// CIR-DAG: cir.global "private" internal dso_local @test_zero_init_padding.paf = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<1> : !s8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 3>, +// CIR-DAG-SAME: #cir.int<42> : !s32i +// CIR-DAG-SAME: }> : !rec_anon_struct3 + +// bfp: unsigned bitfield byte + 3 bytes padding + int -> uses !rec_anon_struct2 +// CIR-DAG: cir.global "private" internal dso_local @test_zero_init_padding.bfp = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<17> : !u8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 3>, +// CIR-DAG-SAME: #cir.int<99> : !s32i +// CIR-DAG-SAME: }> : !rec_anon_struct2 + +// tp: int + char + 3 bytes tail padding -> uses !rec_anon_struct1 +// CIR-DAG: cir.global "private" internal dso_local @test_zero_init_padding.tp = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<10> : !s32i, +// CIR-DAG-SAME: #cir.int<20> : !s8i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 3> +// CIR-DAG-SAME: }> : !rec_anon_struct1 + +// mp: char + 1 byte padding + short + 4 bytes padding + long long -> uses !rec_anon_struct +// CIR-DAG: cir.global "private" internal dso_local @test_zero_init_padding.mp = #cir.const_record<{ +// CIR-DAG-SAME: #cir.int<5> : !s8i, +// CIR-DAG-SAME: #cir.zero : !u8i, +// CIR-DAG-SAME: #cir.int<10> : !s16i, +// CIR-DAG-SAME: #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>, +// CIR-DAG-SAME: #cir.int<100> : !s64i +// CIR-DAG-SAME: }> : !rec_anon_struct + +// CIR-LABEL: cir.func {{.*}}@test_zero_init_padding +// CIR: cir.return + +// LLVM-DAG: @test_zero_init_padding.paf = internal global { i8, [3 x i8], i32 } { i8 1, [3 x i8] zeroinitializer, i32 42 } +// LLVM-DAG: @test_zero_init_padding.bfp = internal global { i8, [3 x i8], i32 } { i8 17, [3 x i8] zeroinitializer, i32 99 } +// LLVM-DAG: @test_zero_init_padding.tp = internal global { i32, i8, [3 x i8] } { i32 10, i8 20, [3 x i8] zeroinitializer } +// LLVM-DAG: @test_zero_init_padding.mp = internal global { i8, i8, i16, [4 x i8], i64 } { i8 5, i8 0, i16 10, [4 x i8] zeroinitializer, i64 100 } + +// LLVM-LABEL: define{{.*}} void @test_zero_init_padding +// LLVM: ret void + +// OGCG-DAG: @test_zero_init_padding.paf = internal constant { i8, [3 x i8], i32 } { i8 1, [3 x i8] zeroinitializer, i32 42 } +// OGCG-DAG: @test_zero_init_padding.bfp = internal constant { i8, [3 x i8], i32 } { i8 17, [3 x i8] zeroinitializer, i32 99 } +// OGCG-DAG: @test_zero_init_padding.tp = internal constant { i32, i8, [3 x i8] } { i32 10, i8 20, [3 x i8] zeroinitializer } +// OGCG-DAG: @test_zero_init_padding.mp = internal constant { i8, i8, i16, [4 x i8], i64 } { i8 5, i8 0, i16 10, [4 x i8] zeroinitializer, i64 100 } + +// OGCG-LABEL: define{{.*}} void @test_zero_init_padding +// OGCG: ret void 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/CodeGen/AArch64/sme-intrinsics/acle_sme_ld1_vnum.c b/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_ld1_vnum.c index e4c93ade..8206e4f 100644 --- a/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_ld1_vnum.c +++ b/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_ld1_vnum.c @@ -10,30 +10,30 @@ // CHECK-C-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z23test_svld1_hor_vnum_za8ju10__SVBool_tPKvl( // CHECK-CXX-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svld1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -46,15 +46,15 @@ void test_svld1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_hor_vnum_za16ju10__SVBool_tPKvl( @@ -62,15 +62,15 @@ void test_svld1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -83,15 +83,15 @@ void test_svld1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_hor_vnum_za32ju10__SVBool_tPKvl( @@ -99,15 +99,15 @@ void test_svld1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -120,15 +120,15 @@ void test_svld1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_hor_vnum_za64ju10__SVBool_tPKvl( @@ -136,15 +136,15 @@ void test_svld1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -157,13 +157,13 @@ void test_svld1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z25test_svld1_hor_vnum_za128ju10__SVBool_tPKvl( @@ -171,13 +171,13 @@ void test_svld1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svld1_hor_vnum_za128(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -189,30 +189,30 @@ void test_svld1_hor_vnum_za128(uint32_t slice_base, svbool_t pg, const void *ptr // CHECK-C-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0]] { // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z22test_svld1_ver_hor_za8ju10__SVBool_tPKvl( // CHECK-CXX-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0]] { // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svld1_ver_hor_za8(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -225,15 +225,15 @@ void test_svld1_ver_hor_za8(uint32_t slice_base, svbool_t pg, const void *ptr, i // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_ver_vnum_za16ju10__SVBool_tPKvl( @@ -241,15 +241,15 @@ void test_svld1_ver_hor_za8(uint32_t slice_base, svbool_t pg, const void *ptr, i // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -262,15 +262,15 @@ void test_svld1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_ver_vnum_za32ju10__SVBool_tPKvl( @@ -278,15 +278,15 @@ void test_svld1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -299,15 +299,15 @@ void test_svld1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svld1_ver_vnum_za64ju10__SVBool_tPKvl( @@ -315,15 +315,15 @@ void test_svld1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svld1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { @@ -336,13 +336,13 @@ void test_svld1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z25test_svld1_ver_vnum_za128ju10__SVBool_tPKvl( @@ -350,13 +350,13 @@ void test_svld1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, const void *ptr, // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.ld1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svld1_ver_vnum_za128(uint32_t slice_base, svbool_t pg, const void *ptr, int64_t vnum) __arm_streaming __arm_out("za") { diff --git a/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_st1_vnum.c b/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_st1_vnum.c index 22a0b9e..507a544 100644 --- a/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_st1_vnum.c +++ b/clang/test/CodeGen/AArch64/sme-intrinsics/acle_sme_st1_vnum.c @@ -10,30 +10,30 @@ // CHECK-C-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z23test_svst1_hor_vnum_za8ju10__SVBool_tPvl( // CHECK-CXX-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.horiz(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svst1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -46,15 +46,15 @@ void test_svst1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_ // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_hor_vnum_za16ju10__SVBool_tPvl( @@ -62,15 +62,15 @@ void test_svst1_hor_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_ // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.horiz(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -83,15 +83,15 @@ void test_svst1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_hor_vnum_za32ju10__SVBool_tPvl( @@ -99,15 +99,15 @@ void test_svst1_hor_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.horiz(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -120,15 +120,15 @@ void test_svst1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_hor_vnum_za64ju10__SVBool_tPvl( @@ -136,15 +136,15 @@ void test_svst1_hor_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.horiz(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -157,13 +157,13 @@ void test_svst1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z25test_svst1_hor_vnum_za128ju10__SVBool_tPvl( @@ -171,13 +171,13 @@ void test_svst1_hor_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.horiz(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svst1_hor_vnum_za128(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -189,30 +189,30 @@ void test_svst1_hor_vnum_za128(uint32_t slice_base, svbool_t pg, void *ptr, int6 // CHECK-C-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0]] { // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z23test_svst1_ver_vnum_za8ju10__SVBool_tPvl( // CHECK-CXX-SAME: i32 noundef [[SLICE_BASE:%.*]], <vscale x 16 x i1> [[PG:%.*]], ptr noundef [[PTR:%.*]], i64 noundef [[VNUM:%.*]]) local_unnamed_addr #[[ATTR0]] { // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP1]], [[TMP0]] -// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 15 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP2]], i32 0, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP3:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP3]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP2]] +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[ADD]], 15 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1b.vert(<vscale x 16 x i1> [[PG]], ptr [[TMP1]], i32 0, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svst1_ver_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -225,15 +225,15 @@ void test_svst1_ver_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_ // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_ver_vnum_za16ju10__SVBool_tPvl( @@ -241,15 +241,15 @@ void test_svst1_ver_vnum_za8(uint32_t slice_base, svbool_t pg, void *ptr, int64_ // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 7 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP3]], i32 1, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 7 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1h.vert(<vscale x 8 x i1> [[TMP0]], ptr [[TMP2]], i32 1, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -262,15 +262,15 @@ void test_svst1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_ver_vnum_za32ju10__SVBool_tPvl( @@ -278,15 +278,15 @@ void test_svst1_ver_vnum_za16(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 3 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP3]], i32 3, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 3 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1w.vert(<vscale x 4 x i1> [[TMP0]], ptr [[TMP2]], i32 3, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -299,15 +299,15 @@ void test_svst1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z24test_svst1_ver_vnum_za64ju10__SVBool_tPvl( @@ -315,15 +315,15 @@ void test_svst1_ver_vnum_za32(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: [[TMP6:%.*]] = add i32 [[ADD]], 1 -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP3]], i32 7, i32 [[TMP6]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: [[ADD:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[ADD]], 1 +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1d.vert(<vscale x 2 x i1> [[TMP0]], ptr [[TMP2]], i32 7, i32 [[TMP5]]) // CHECK-CXX-NEXT: ret void // void test_svst1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { @@ -336,13 +336,13 @@ void test_svst1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-C-NEXT: entry: // CHECK-C-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-C-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-C-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-C-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-C-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-C-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-C-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-C-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-C-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-C-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-C-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-C-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-C-NEXT: ret void // // CHECK-CXX-LABEL: define dso_local void @_Z25test_svst1_ver_vnum_za128ju10__SVBool_tPvl( @@ -350,13 +350,13 @@ void test_svst1_ver_vnum_za64(uint32_t slice_base, svbool_t pg, void *ptr, int64 // CHECK-CXX-NEXT: entry: // CHECK-CXX-NEXT: [[TMP0:%.*]] = tail call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> [[PG]]) // CHECK-CXX-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-CXX-NEXT: [[TMP2:%.*]] = shl i64 [[VNUM]], 4 -// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[TMP2]], [[TMP1]] -// CHECK-CXX-NEXT: [[TMP3:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] -// CHECK-CXX-NEXT: [[TMP4:%.*]] = trunc i64 [[VNUM]] to i32 -// CHECK-CXX-NEXT: [[TMP5:%.*]] = add i32 [[SLICE_BASE]], [[TMP4]] -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 0, i32 [[TMP5]]) -// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP3]], i32 15, i32 [[TMP5]]) +// CHECK-CXX-NEXT: [[SVL:%.*]] = shl nuw nsw i64 [[TMP1]], 4 +// CHECK-CXX-NEXT: [[MULVL:%.*]] = mul i64 [[SVL]], [[VNUM]] +// CHECK-CXX-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 [[MULVL]] +// CHECK-CXX-NEXT: [[TMP3:%.*]] = trunc i64 [[VNUM]] to i32 +// CHECK-CXX-NEXT: [[TMP4:%.*]] = add i32 [[SLICE_BASE]], [[TMP3]] +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 0, i32 [[TMP4]]) +// CHECK-CXX-NEXT: tail call void @llvm.aarch64.sme.st1q.vert(<vscale x 1 x i1> [[TMP0]], ptr [[TMP2]], i32 15, i32 [[TMP4]]) // CHECK-CXX-NEXT: ret void // void test_svst1_ver_vnum_za128(uint32_t slice_base, svbool_t pg, void *ptr, int64_t vnum) __arm_streaming __arm_in("za") { 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/AArch64/sve2p1-intrinsics/acle_sve2p1_ld1.c b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ld1.c index af39be3..6471ab4 100644 --- a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ld1.c +++ b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ld1.c @@ -390,8 +390,8 @@ svmfloat8x4_t test_svld1_mf8_x4(svcount_t pn, const mfloat8_t *base) ATTR // CHECK-LABEL: @test_svld1_vnum_u8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -399,8 +399,8 @@ svmfloat8x4_t test_svld1_mf8_x4(svcount_t pn, const mfloat8_t *base) ATTR // CPP-CHECK-LABEL: @_Z21test_svld1_vnum_u8_x2u11__SVCount_tPKhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -413,8 +413,8 @@ svuint8x2_t test_svld1_vnum_u8_x2(svcount_t pn, const uint8_t *base, int64_t vnu // CHECK-LABEL: @test_svld1_vnum_u16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -422,8 +422,8 @@ svuint8x2_t test_svld1_vnum_u8_x2(svcount_t pn, const uint8_t *base, int64_t vnu // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u16_x2u11__SVCount_tPKtl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -436,8 +436,8 @@ svuint16x2_t test_svld1_vnum_u16_x2(svcount_t pn, const uint16_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_u32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -445,8 +445,8 @@ svuint16x2_t test_svld1_vnum_u16_x2(svcount_t pn, const uint16_t *base, int64_t // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u32_x2u11__SVCount_tPKjl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -459,8 +459,8 @@ svuint32x2_t test_svld1_vnum_u32_x2(svcount_t pn, const uint32_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_u64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -468,8 +468,8 @@ svuint32x2_t test_svld1_vnum_u32_x2(svcount_t pn, const uint32_t *base, int64_t // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u64_x2u11__SVCount_tPKml( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -482,8 +482,8 @@ svuint64x2_t test_svld1_vnum_u64_x2(svcount_t pn, const uint64_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_u8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -491,8 +491,8 @@ svuint64x2_t test_svld1_vnum_u64_x2(svcount_t pn, const uint64_t *base, int64_t // CPP-CHECK-LABEL: @_Z21test_svld1_vnum_u8_x4u11__SVCount_tPKhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -505,8 +505,8 @@ svuint8x4_t test_svld1_vnum_u8_x4(svcount_t pn, const uint8_t *base, int64_t vnu // CHECK-LABEL: @test_svld1_vnum_u16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -514,8 +514,8 @@ svuint8x4_t test_svld1_vnum_u8_x4(svcount_t pn, const uint8_t *base, int64_t vnu // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u16_x4u11__SVCount_tPKtl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -528,8 +528,8 @@ svuint16x4_t test_svld1_vnum_u16_x4(svcount_t pn, const uint16_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_u32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -537,8 +537,8 @@ svuint16x4_t test_svld1_vnum_u16_x4(svcount_t pn, const uint16_t *base, int64_t // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u32_x4u11__SVCount_tPKjl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -551,8 +551,8 @@ svuint32x4_t test_svld1_vnum_u32_x4(svcount_t pn, const uint32_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_u64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -560,8 +560,8 @@ svuint32x4_t test_svld1_vnum_u32_x4(svcount_t pn, const uint32_t *base, int64_t // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_u64_x4u11__SVCount_tPKml( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -574,8 +574,8 @@ svuint64x4_t test_svld1_vnum_u64_x4(svcount_t pn, const uint64_t *base, int64_t // CHECK-LABEL: @test_svld1_vnum_s8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -583,8 +583,8 @@ svuint64x4_t test_svld1_vnum_u64_x4(svcount_t pn, const uint64_t *base, int64_t // CPP-CHECK-LABEL: @_Z21test_svld1_vnum_s8_x2u11__SVCount_tPKal( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -597,8 +597,8 @@ svint8x2_t test_svld1_vnum_s8_x2(svcount_t pn, const int8_t *base, int64_t vnum) // CHECK-LABEL: @test_svld1_vnum_s16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -606,8 +606,8 @@ svint8x2_t test_svld1_vnum_s8_x2(svcount_t pn, const int8_t *base, int64_t vnum) // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s16_x2u11__SVCount_tPKsl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -620,8 +620,8 @@ svint16x2_t test_svld1_vnum_s16_x2(svcount_t pn, const int16_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_s32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -629,8 +629,8 @@ svint16x2_t test_svld1_vnum_s16_x2(svcount_t pn, const int16_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s32_x2u11__SVCount_tPKil( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -643,8 +643,8 @@ svint32x2_t test_svld1_vnum_s32_x2(svcount_t pn, const int32_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_s64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -652,8 +652,8 @@ svint32x2_t test_svld1_vnum_s32_x2(svcount_t pn, const int32_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s64_x2u11__SVCount_tPKll( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -666,8 +666,8 @@ svint64x2_t test_svld1_vnum_s64_x2(svcount_t pn, const int64_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_s8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -675,8 +675,8 @@ svint64x2_t test_svld1_vnum_s64_x2(svcount_t pn, const int64_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z21test_svld1_vnum_s8_x4u11__SVCount_tPKal( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -689,8 +689,8 @@ svint8x4_t test_svld1_vnum_s8_x4(svcount_t pn, const int8_t *base, int64_t vnum) // CHECK-LABEL: @test_svld1_vnum_s16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -698,8 +698,8 @@ svint8x4_t test_svld1_vnum_s8_x4(svcount_t pn, const int8_t *base, int64_t vnum) // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s16_x4u11__SVCount_tPKsl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ld1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -712,8 +712,8 @@ svint16x4_t test_svld1_vnum_s16_x4(svcount_t pn, const int16_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_s32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -721,8 +721,8 @@ svint16x4_t test_svld1_vnum_s16_x4(svcount_t pn, const int16_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s32_x4u11__SVCount_tPKil( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ld1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -735,8 +735,8 @@ svint32x4_t test_svld1_vnum_s32_x4(svcount_t pn, const int32_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_s64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -744,8 +744,8 @@ svint32x4_t test_svld1_vnum_s32_x4(svcount_t pn, const int32_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_s64_x4u11__SVCount_tPKll( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ld1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -758,8 +758,8 @@ svint64x4_t test_svld1_vnum_s64_x4(svcount_t pn, const int64_t *base, int64_t vn // CHECK-LABEL: @test_svld1_vnum_f16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ld1.pn.x2.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -767,8 +767,8 @@ svint64x4_t test_svld1_vnum_s64_x4(svcount_t pn, const int64_t *base, int64_t vn // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f16_x2u11__SVCount_tPKDhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ld1.pn.x2.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -781,8 +781,8 @@ svfloat16x2_t test_svld1_vnum_f16_x2(svcount_t pn, const float16_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_f32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ld1.pn.x2.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -790,8 +790,8 @@ svfloat16x2_t test_svld1_vnum_f16_x2(svcount_t pn, const float16_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f32_x2u11__SVCount_tPKfl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ld1.pn.x2.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -804,8 +804,8 @@ svfloat32x2_t test_svld1_vnum_f32_x2(svcount_t pn, const float32_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_f64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ld1.pn.x2.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -813,8 +813,8 @@ svfloat32x2_t test_svld1_vnum_f32_x2(svcount_t pn, const float32_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f64_x2u11__SVCount_tPKdl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ld1.pn.x2.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -827,8 +827,8 @@ svfloat64x2_t test_svld1_vnum_f64_x2(svcount_t pn, const float64_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_mf8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -836,8 +836,8 @@ svfloat64x2_t test_svld1_vnum_f64_x2(svcount_t pn, const float64_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_mf8_x2u11__SVCount_tPKu6__mfp8l( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -850,8 +850,8 @@ svmfloat8x2_t test_svld1_vnum_mf8_x2(svcount_t pn, const mfloat8_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_f16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ld1.pn.x4.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -859,8 +859,8 @@ svmfloat8x2_t test_svld1_vnum_mf8_x2(svcount_t pn, const mfloat8_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f16_x4u11__SVCount_tPKDhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ld1.pn.x4.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -873,8 +873,8 @@ svfloat16x4_t test_svld1_vnum_f16_x4(svcount_t pn, const float16_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_f32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ld1.pn.x4.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -882,8 +882,8 @@ svfloat16x4_t test_svld1_vnum_f16_x4(svcount_t pn, const float16_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f32_x4u11__SVCount_tPKfl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ld1.pn.x4.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -896,8 +896,8 @@ svfloat32x4_t test_svld1_vnum_f32_x4(svcount_t pn, const float32_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_f64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ld1.pn.x4.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -905,8 +905,8 @@ svfloat32x4_t test_svld1_vnum_f32_x4(svcount_t pn, const float32_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_f64_x4u11__SVCount_tPKdl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ld1.pn.x4.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -919,8 +919,8 @@ svfloat64x4_t test_svld1_vnum_f64_x4(svcount_t pn, const float64_t *base, int64_ // CHECK-LABEL: @test_svld1_vnum_mf8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -928,8 +928,8 @@ svfloat64x4_t test_svld1_vnum_f64_x4(svcount_t pn, const float64_t *base, int64_ // CPP-CHECK-LABEL: @_Z22test_svld1_vnum_mf8_x4u11__SVCount_tPKu6__mfp8l( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ld1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] diff --git a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ldnt1.c b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ldnt1.c index 02c7586..cd92b61 100644 --- a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ldnt1.c +++ b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_ldnt1.c @@ -388,8 +388,8 @@ svmfloat8x4_t test_svldnt1_mf8_x4(svcount_t pn, const mfloat8_t *base) ATTR // CHECK-LABEL: @test_svldnt1_vnum_u8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -397,8 +397,8 @@ svmfloat8x4_t test_svldnt1_mf8_x4(svcount_t pn, const mfloat8_t *base) ATTR // CPP-CHECK-LABEL: @_Z23test_svldnt1_vnum_u8_x2u11__SVCount_tPKhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -411,8 +411,8 @@ svuint8x2_t test_svldnt1_vnum_u8_x2(svcount_t pn, const uint8_t *base, int64_t v // CHECK-LABEL: @test_svldnt1_vnum_u16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -420,8 +420,8 @@ svuint8x2_t test_svldnt1_vnum_u8_x2(svcount_t pn, const uint8_t *base, int64_t v // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u16_x2u11__SVCount_tPKtl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -434,8 +434,8 @@ svuint16x2_t test_svldnt1_vnum_u16_x2(svcount_t pn, const uint16_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_u32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -443,8 +443,8 @@ svuint16x2_t test_svldnt1_vnum_u16_x2(svcount_t pn, const uint16_t *base, int64_ // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u32_x2u11__SVCount_tPKjl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -457,8 +457,8 @@ svuint32x2_t test_svldnt1_vnum_u32_x2(svcount_t pn, const uint32_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_u64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -466,8 +466,8 @@ svuint32x2_t test_svldnt1_vnum_u32_x2(svcount_t pn, const uint32_t *base, int64_ // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u64_x2u11__SVCount_tPKml( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -480,8 +480,8 @@ svuint64x2_t test_svldnt1_vnum_u64_x2(svcount_t pn, const uint64_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_u8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -489,8 +489,8 @@ svuint64x2_t test_svldnt1_vnum_u64_x2(svcount_t pn, const uint64_t *base, int64_ // CPP-CHECK-LABEL: @_Z23test_svldnt1_vnum_u8_x4u11__SVCount_tPKhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -503,8 +503,8 @@ svuint8x4_t test_svldnt1_vnum_u8_x4(svcount_t pn, const uint8_t *base, int64_t v // CHECK-LABEL: @test_svldnt1_vnum_u16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -512,8 +512,8 @@ svuint8x4_t test_svldnt1_vnum_u8_x4(svcount_t pn, const uint8_t *base, int64_t v // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u16_x4u11__SVCount_tPKtl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -526,8 +526,8 @@ svuint16x4_t test_svldnt1_vnum_u16_x4(svcount_t pn, const uint16_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_u32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -535,8 +535,8 @@ svuint16x4_t test_svldnt1_vnum_u16_x4(svcount_t pn, const uint16_t *base, int64_ // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u32_x4u11__SVCount_tPKjl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -549,8 +549,8 @@ svuint32x4_t test_svldnt1_vnum_u32_x4(svcount_t pn, const uint32_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_u64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -558,8 +558,8 @@ svuint32x4_t test_svldnt1_vnum_u32_x4(svcount_t pn, const uint32_t *base, int64_ // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_u64_x4u11__SVCount_tPKml( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -572,8 +572,8 @@ svuint64x4_t test_svldnt1_vnum_u64_x4(svcount_t pn, const uint64_t *base, int64_ // CHECK-LABEL: @test_svldnt1_vnum_s8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -581,8 +581,8 @@ svuint64x4_t test_svldnt1_vnum_u64_x4(svcount_t pn, const uint64_t *base, int64_ // CPP-CHECK-LABEL: @_Z23test_svldnt1_vnum_s8_x2u11__SVCount_tPKal( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -595,8 +595,8 @@ svint8x2_t test_svldnt1_vnum_s8_x2(svcount_t pn, const int8_t *base, int64_t vnu // CHECK-LABEL: @test_svldnt1_vnum_s16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -604,8 +604,8 @@ svint8x2_t test_svldnt1_vnum_s8_x2(svcount_t pn, const int8_t *base, int64_t vnu // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s16_x2u11__SVCount_tPKsl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -618,8 +618,8 @@ svint16x2_t test_svldnt1_vnum_s16_x2(svcount_t pn, const int16_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_s32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -627,8 +627,8 @@ svint16x2_t test_svldnt1_vnum_s16_x2(svcount_t pn, const int16_t *base, int64_t // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s32_x2u11__SVCount_tPKil( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -641,8 +641,8 @@ svint32x2_t test_svldnt1_vnum_s32_x2(svcount_t pn, const int32_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_s64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -650,8 +650,8 @@ svint32x2_t test_svldnt1_vnum_s32_x2(svcount_t pn, const int32_t *base, int64_t // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s64_x2u11__SVCount_tPKll( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -664,8 +664,8 @@ svint64x2_t test_svldnt1_vnum_s64_x2(svcount_t pn, const int64_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_s8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -673,8 +673,8 @@ svint64x2_t test_svldnt1_vnum_s64_x2(svcount_t pn, const int64_t *base, int64_t // CPP-CHECK-LABEL: @_Z23test_svldnt1_vnum_s8_x4u11__SVCount_tPKal( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -687,8 +687,8 @@ svint8x4_t test_svldnt1_vnum_s8_x4(svcount_t pn, const int8_t *base, int64_t vnu // CHECK-LABEL: @test_svldnt1_vnum_s16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -696,8 +696,8 @@ svint8x4_t test_svldnt1_vnum_s8_x4(svcount_t pn, const int8_t *base, int64_t vnu // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s16_x4u11__SVCount_tPKsl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8i16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 8 x i16> } [[TMP3]] @@ -710,8 +710,8 @@ svint16x4_t test_svldnt1_vnum_s16_x4(svcount_t pn, const int16_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_s32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -719,8 +719,8 @@ svint16x4_t test_svldnt1_vnum_s16_x4(svcount_t pn, const int16_t *base, int64_t // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s32_x4u11__SVCount_tPKil( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4i32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32>, <vscale x 4 x i32> } [[TMP3]] @@ -733,8 +733,8 @@ svint32x4_t test_svldnt1_vnum_s32_x4(svcount_t pn, const int32_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_s64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -742,8 +742,8 @@ svint32x4_t test_svldnt1_vnum_s32_x4(svcount_t pn, const int32_t *base, int64_t // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_s64_x4u11__SVCount_tPKll( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2i64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64> } [[TMP3]] @@ -756,8 +756,8 @@ svint64x4_t test_svldnt1_vnum_s64_x4(svcount_t pn, const int64_t *base, int64_t // CHECK-LABEL: @test_svldnt1_vnum_f16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -765,8 +765,8 @@ svint64x4_t test_svldnt1_vnum_s64_x4(svcount_t pn, const int64_t *base, int64_t // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f16_x2u11__SVCount_tPKDhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -779,8 +779,8 @@ svfloat16x2_t test_svldnt1_vnum_f16_x2(svcount_t pn, const float16_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_f32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -788,8 +788,8 @@ svfloat16x2_t test_svldnt1_vnum_f16_x2(svcount_t pn, const float16_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f32_x2u11__SVCount_tPKfl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -802,8 +802,8 @@ svfloat32x2_t test_svldnt1_vnum_f32_x2(svcount_t pn, const float32_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_f64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -811,8 +811,8 @@ svfloat32x2_t test_svldnt1_vnum_f32_x2(svcount_t pn, const float32_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f64_x2u11__SVCount_tPKdl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -825,8 +825,8 @@ svfloat64x2_t test_svldnt1_vnum_f64_x2(svcount_t pn, const float64_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_mf8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -834,8 +834,8 @@ svfloat64x2_t test_svldnt1_vnum_f64_x2(svcount_t pn, const float64_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_mf8_x2u11__SVCount_tPKu6__mfp8l( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x2.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -848,8 +848,8 @@ svmfloat8x2_t test_svldnt1_vnum_mf8_x2(svcount_t pn, const mfloat8_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_f16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -857,8 +857,8 @@ svmfloat8x2_t test_svldnt1_vnum_mf8_x2(svcount_t pn, const mfloat8_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f16_x4u11__SVCount_tPKDhl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv8f16(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half>, <vscale x 8 x half> } [[TMP3]] @@ -871,8 +871,8 @@ svfloat16x4_t test_svldnt1_vnum_f16_x4(svcount_t pn, const float16_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_f32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -880,8 +880,8 @@ svfloat16x4_t test_svldnt1_vnum_f16_x4(svcount_t pn, const float16_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f32_x4u11__SVCount_tPKfl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv4f32(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float> } [[TMP3]] @@ -894,8 +894,8 @@ svfloat32x4_t test_svldnt1_vnum_f32_x4(svcount_t pn, const float32_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_f64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -903,8 +903,8 @@ svfloat32x4_t test_svldnt1_vnum_f32_x4(svcount_t pn, const float32_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_f64_x4u11__SVCount_tPKdl( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv2f64(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double> } [[TMP3]] @@ -917,8 +917,8 @@ svfloat64x4_t test_svldnt1_vnum_f64_x4(svcount_t pn, const float64_t *base, int6 // CHECK-LABEL: @test_svldnt1_vnum_mf8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] @@ -926,8 +926,8 @@ svfloat64x4_t test_svldnt1_vnum_f64_x4(svcount_t pn, const float64_t *base, int6 // CPP-CHECK-LABEL: @_Z24test_svldnt1_vnum_mf8_x4u11__SVCount_tPKu6__mfp8l( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: [[TMP3:%.*]] = tail call { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } @llvm.aarch64.sve.ldnt1.pn.x4.nxv16i8(target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret { <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8>, <vscale x 16 x i8> } [[TMP3]] diff --git a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_st1.c b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_st1.c index 092f31b..9920aba 100644 --- a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_st1.c +++ b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_st1.c @@ -388,8 +388,8 @@ void test_svst1_mf8_x4(svcount_t pn, mfloat8_t *base, svmfloat8x4_t v) ATTR // CHECK-LABEL: @test_svst1_vnum_u8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -397,8 +397,8 @@ void test_svst1_mf8_x4(svcount_t pn, mfloat8_t *base, svmfloat8x4_t v) ATTR // CPP-CHECK-LABEL: @_Z21test_svst1_vnum_u8_x2u11__SVCount_tPhl11svuint8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -411,8 +411,8 @@ void test_svst1_vnum_u8_x2(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x2_ // CHECK-LABEL: @test_svst1_vnum_u16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -420,8 +420,8 @@ void test_svst1_vnum_u8_x2(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x2_ // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u16_x2u11__SVCount_tPtl12svuint16x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -434,8 +434,8 @@ void test_svst1_vnum_u16_x2(svcount_t pn, uint16_t *base, int64_t vnum, svuint16 // CHECK-LABEL: @test_svst1_vnum_u32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -443,8 +443,8 @@ void test_svst1_vnum_u16_x2(svcount_t pn, uint16_t *base, int64_t vnum, svuint16 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u32_x2u11__SVCount_tPjl12svuint32x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -457,8 +457,8 @@ void test_svst1_vnum_u32_x2(svcount_t pn, uint32_t *base, int64_t vnum, svuint32 // CHECK-LABEL: @test_svst1_vnum_u64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -466,8 +466,8 @@ void test_svst1_vnum_u32_x2(svcount_t pn, uint32_t *base, int64_t vnum, svuint32 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u64_x2u11__SVCount_tPml12svuint64x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -480,8 +480,8 @@ void test_svst1_vnum_u64_x2(svcount_t pn, uint64_t *base, int64_t vnum, svuint64 // CHECK-LABEL: @test_svst1_vnum_u8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -489,8 +489,8 @@ void test_svst1_vnum_u64_x2(svcount_t pn, uint64_t *base, int64_t vnum, svuint64 // CPP-CHECK-LABEL: @_Z21test_svst1_vnum_u8_x4u11__SVCount_tPhl11svuint8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -503,8 +503,8 @@ void test_svst1_vnum_u8_x4(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x4_ // CHECK-LABEL: @test_svst1_vnum_u16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -512,8 +512,8 @@ void test_svst1_vnum_u8_x4(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x4_ // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u16_x4u11__SVCount_tPtl12svuint16x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -526,8 +526,8 @@ void test_svst1_vnum_u16_x4(svcount_t pn, uint16_t *base, int64_t vnum, svuint16 // CHECK-LABEL: @test_svst1_vnum_u32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -535,8 +535,8 @@ void test_svst1_vnum_u16_x4(svcount_t pn, uint16_t *base, int64_t vnum, svuint16 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u32_x4u11__SVCount_tPjl12svuint32x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -549,8 +549,8 @@ void test_svst1_vnum_u32_x4(svcount_t pn, uint32_t *base, int64_t vnum, svuint32 // CHECK-LABEL: @test_svst1_vnum_u64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -558,8 +558,8 @@ void test_svst1_vnum_u32_x4(svcount_t pn, uint32_t *base, int64_t vnum, svuint32 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_u64_x4u11__SVCount_tPml12svuint64x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -572,8 +572,8 @@ void test_svst1_vnum_u64_x4(svcount_t pn, uint64_t *base, int64_t vnum, svuint64 // CHECK-LABEL: @test_svst1_vnum_s8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -581,8 +581,8 @@ void test_svst1_vnum_u64_x4(svcount_t pn, uint64_t *base, int64_t vnum, svuint64 // CPP-CHECK-LABEL: @_Z21test_svst1_vnum_s8_x2u11__SVCount_tPal10svint8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -595,8 +595,8 @@ void test_svst1_vnum_s8_x2(svcount_t pn, int8_t *base, int64_t vnum, svint8x2_t // CHECK-LABEL: @test_svst1_vnum_s16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -604,8 +604,8 @@ void test_svst1_vnum_s8_x2(svcount_t pn, int8_t *base, int64_t vnum, svint8x2_t // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s16_x2u11__SVCount_tPsl11svint16x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -618,8 +618,8 @@ void test_svst1_vnum_s16_x2(svcount_t pn, int16_t *base, int64_t vnum, svint16x2 // CHECK-LABEL: @test_svst1_vnum_s32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -627,8 +627,8 @@ void test_svst1_vnum_s16_x2(svcount_t pn, int16_t *base, int64_t vnum, svint16x2 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s32_x2u11__SVCount_tPil11svint32x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -641,8 +641,8 @@ void test_svst1_vnum_s32_x2(svcount_t pn, int32_t *base, int64_t vnum, svint32x2 // CHECK-LABEL: @test_svst1_vnum_s64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -650,8 +650,8 @@ void test_svst1_vnum_s32_x2(svcount_t pn, int32_t *base, int64_t vnum, svint32x2 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s64_x2u11__SVCount_tPll11svint64x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -664,8 +664,8 @@ void test_svst1_vnum_s64_x2(svcount_t pn, int64_t *base, int64_t vnum, svint64x2 // CHECK-LABEL: @test_svst1_vnum_s8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -673,8 +673,8 @@ void test_svst1_vnum_s64_x2(svcount_t pn, int64_t *base, int64_t vnum, svint64x2 // CPP-CHECK-LABEL: @_Z21test_svst1_vnum_s8_x4u11__SVCount_tPal10svint8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -687,8 +687,8 @@ void test_svst1_vnum_s8_x4(svcount_t pn, int8_t *base, int64_t vnum, svint8x4_t // CHECK-LABEL: @test_svst1_vnum_s16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -696,8 +696,8 @@ void test_svst1_vnum_s8_x4(svcount_t pn, int8_t *base, int64_t vnum, svint8x4_t // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s16_x4u11__SVCount_tPsl11svint16x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -710,8 +710,8 @@ void test_svst1_vnum_s16_x4(svcount_t pn, int16_t *base, int64_t vnum, svint16x4 // CHECK-LABEL: @test_svst1_vnum_s32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -719,8 +719,8 @@ void test_svst1_vnum_s16_x4(svcount_t pn, int16_t *base, int64_t vnum, svint16x4 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s32_x4u11__SVCount_tPil11svint32x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -733,8 +733,8 @@ void test_svst1_vnum_s32_x4(svcount_t pn, int32_t *base, int64_t vnum, svint32x4 // CHECK-LABEL: @test_svst1_vnum_s64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -742,8 +742,8 @@ void test_svst1_vnum_s32_x4(svcount_t pn, int32_t *base, int64_t vnum, svint32x4 // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_s64_x4u11__SVCount_tPll11svint64x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -757,8 +757,8 @@ void test_svst1_vnum_s64_x4(svcount_t pn, int64_t *base, int64_t vnum, svint64x4 // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -767,8 +767,8 @@ void test_svst1_vnum_s64_x4(svcount_t pn, int64_t *base, int64_t vnum, svint64x4 // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -782,8 +782,8 @@ void test_svst1_vnum_f16_x2(svcount_t pn, float16_t *base, float64_t vnum, svflo // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -792,8 +792,8 @@ void test_svst1_vnum_f16_x2(svcount_t pn, float16_t *base, float64_t vnum, svflo // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -807,8 +807,8 @@ void test_svst1_vnum_f32_x2(svcount_t pn, float32_t *base, float64_t vnum, svflo // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -817,8 +817,8 @@ void test_svst1_vnum_f32_x2(svcount_t pn, float32_t *base, float64_t vnum, svflo // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -831,8 +831,8 @@ void test_svst1_vnum_f64_x2(svcount_t pn, float64_t *base, float64_t vnum, svflo // CHECK-LABEL: @test_svst1_vnum_mf8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -840,8 +840,8 @@ void test_svst1_vnum_f64_x2(svcount_t pn, float64_t *base, float64_t vnum, svflo // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_mf8_x2u11__SVCount_tPu6__mfp8l13svmfloat8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -855,8 +855,8 @@ void test_svst1_vnum_mf8_x2(svcount_t pn, mfloat8_t *base, int64_t vnum, svmfloa // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], <vscale x 8 x half> [[V_COERCE2:%.*]], <vscale x 8 x half> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -865,8 +865,8 @@ void test_svst1_vnum_mf8_x2(svcount_t pn, mfloat8_t *base, int64_t vnum, svmfloa // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], <vscale x 8 x half> [[V_COERCE2:%.*]], <vscale x 8 x half> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -880,8 +880,8 @@ void test_svst1_vnum_f16_x4(svcount_t pn, float16_t *base, float64_t vnum, svflo // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], <vscale x 4 x float> [[V_COERCE2:%.*]], <vscale x 4 x float> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -890,8 +890,8 @@ void test_svst1_vnum_f16_x4(svcount_t pn, float16_t *base, float64_t vnum, svflo // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], <vscale x 4 x float> [[V_COERCE2:%.*]], <vscale x 4 x float> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -905,8 +905,8 @@ void test_svst1_vnum_f32_x4(svcount_t pn, float32_t *base, float64_t vnum, svflo // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], <vscale x 2 x double> [[V_COERCE2:%.*]], <vscale x 2 x double> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -915,8 +915,8 @@ void test_svst1_vnum_f32_x4(svcount_t pn, float32_t *base, float64_t vnum, svflo // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], <vscale x 2 x double> [[V_COERCE2:%.*]], <vscale x 2 x double> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -929,8 +929,8 @@ void test_svst1_vnum_f64_x4(svcount_t pn, float64_t *base, float64_t vnum, svflo // CHECK-LABEL: @test_svst1_vnum_mf8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -938,8 +938,8 @@ void test_svst1_vnum_f64_x4(svcount_t pn, float64_t *base, float64_t vnum, svflo // CPP-CHECK-LABEL: @_Z22test_svst1_vnum_mf8_x4u11__SVCount_tPu6__mfp8l13svmfloat8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.st1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void diff --git a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_stnt1.c b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_stnt1.c index 99dff2c0..90045b0 100644 --- a/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_stnt1.c +++ b/clang/test/CodeGen/AArch64/sve2p1-intrinsics/acle_sve2p1_stnt1.c @@ -409,8 +409,8 @@ void test_svstnt1_mf8_x4(svcount_t pn, mfloat8_t *base, svmfloat8x4_t v) ATTR // CHECK-LABEL: @test_svstnt1_vnum_u8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -418,8 +418,8 @@ void test_svstnt1_mf8_x4(svcount_t pn, mfloat8_t *base, svmfloat8x4_t v) ATTR // CPP-CHECK-LABEL: @_Z23test_svstnt1_vnum_u8_x2u11__SVCount_tPhl11svuint8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -433,8 +433,8 @@ void test_svstnt1_vnum_u8_x2(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x // CHECK-LABEL: @test_svstnt1_vnum_u16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -442,8 +442,8 @@ void test_svstnt1_vnum_u8_x2(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u16_x2u11__SVCount_tPtl12svuint16x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -457,8 +457,8 @@ void test_svstnt1_vnum_u16_x2(svcount_t pn, uint16_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_u32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -466,8 +466,8 @@ void test_svstnt1_vnum_u16_x2(svcount_t pn, uint16_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u32_x2u11__SVCount_tPjl12svuint32x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -481,8 +481,8 @@ void test_svstnt1_vnum_u32_x2(svcount_t pn, uint32_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_u64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -490,8 +490,8 @@ void test_svstnt1_vnum_u32_x2(svcount_t pn, uint32_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u64_x2u11__SVCount_tPml12svuint64x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -505,8 +505,8 @@ void test_svstnt1_vnum_u64_x2(svcount_t pn, uint64_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_u8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -514,8 +514,8 @@ void test_svstnt1_vnum_u64_x2(svcount_t pn, uint64_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z23test_svstnt1_vnum_u8_x4u11__SVCount_tPhl11svuint8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -529,8 +529,8 @@ void test_svstnt1_vnum_u8_x4(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x // CHECK-LABEL: @test_svstnt1_vnum_u16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -538,8 +538,8 @@ void test_svstnt1_vnum_u8_x4(svcount_t pn, uint8_t *base, int64_t vnum, svuint8x // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u16_x4u11__SVCount_tPtl12svuint16x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -553,8 +553,8 @@ void test_svstnt1_vnum_u16_x4(svcount_t pn, uint16_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_u32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -562,8 +562,8 @@ void test_svstnt1_vnum_u16_x4(svcount_t pn, uint16_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u32_x4u11__SVCount_tPjl12svuint32x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -577,8 +577,8 @@ void test_svstnt1_vnum_u32_x4(svcount_t pn, uint32_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_u64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -586,8 +586,8 @@ void test_svstnt1_vnum_u32_x4(svcount_t pn, uint32_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_u64_x4u11__SVCount_tPml12svuint64x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -601,8 +601,8 @@ void test_svstnt1_vnum_u64_x4(svcount_t pn, uint64_t *base, int64_t vnum, svuint // CHECK-LABEL: @test_svstnt1_vnum_s8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -610,8 +610,8 @@ void test_svstnt1_vnum_u64_x4(svcount_t pn, uint64_t *base, int64_t vnum, svuint // CPP-CHECK-LABEL: @_Z23test_svstnt1_vnum_s8_x2u11__SVCount_tPal10svint8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -625,8 +625,8 @@ void test_svstnt1_vnum_s8_x2(svcount_t pn, int8_t *base, int64_t vnum, svint8x2_ // CHECK-LABEL: @test_svstnt1_vnum_s16_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -634,8 +634,8 @@ void test_svstnt1_vnum_s8_x2(svcount_t pn, int8_t *base, int64_t vnum, svint8x2_ // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s16_x2u11__SVCount_tPsl11svint16x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -649,8 +649,8 @@ void test_svstnt1_vnum_s16_x2(svcount_t pn, int16_t *base, int64_t vnum, svint16 // CHECK-LABEL: @test_svstnt1_vnum_s32_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -658,8 +658,8 @@ void test_svstnt1_vnum_s16_x2(svcount_t pn, int16_t *base, int64_t vnum, svint16 // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s32_x2u11__SVCount_tPil11svint32x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -673,8 +673,8 @@ void test_svstnt1_vnum_s32_x2(svcount_t pn, int32_t *base, int64_t vnum, svint32 // CHECK-LABEL: @test_svstnt1_vnum_s64_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -682,8 +682,8 @@ void test_svstnt1_vnum_s32_x2(svcount_t pn, int32_t *base, int64_t vnum, svint32 // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s64_x2u11__SVCount_tPll11svint64x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -697,8 +697,8 @@ void test_svstnt1_vnum_s64_x2(svcount_t pn, int64_t *base, int64_t vnum, svint64 // CHECK-LABEL: @test_svstnt1_vnum_s8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -706,8 +706,8 @@ void test_svstnt1_vnum_s64_x2(svcount_t pn, int64_t *base, int64_t vnum, svint64 // CPP-CHECK-LABEL: @_Z23test_svstnt1_vnum_s8_x4u11__SVCount_tPal10svint8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -721,8 +721,8 @@ void test_svstnt1_vnum_s8_x4(svcount_t pn, int8_t *base, int64_t vnum, svint8x4_ // CHECK-LABEL: @test_svstnt1_vnum_s16_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -730,8 +730,8 @@ void test_svstnt1_vnum_s8_x4(svcount_t pn, int8_t *base, int64_t vnum, svint8x4_ // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s16_x4u11__SVCount_tPsl11svint16x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8i16(<vscale x 8 x i16> [[V_COERCE0:%.*]], <vscale x 8 x i16> [[V_COERCE1:%.*]], <vscale x 8 x i16> [[V_COERCE2:%.*]], <vscale x 8 x i16> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -745,8 +745,8 @@ void test_svstnt1_vnum_s16_x4(svcount_t pn, int16_t *base, int64_t vnum, svint16 // CHECK-LABEL: @test_svstnt1_vnum_s32_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -754,8 +754,8 @@ void test_svstnt1_vnum_s16_x4(svcount_t pn, int16_t *base, int64_t vnum, svint16 // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s32_x4u11__SVCount_tPil11svint32x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4i32(<vscale x 4 x i32> [[V_COERCE0:%.*]], <vscale x 4 x i32> [[V_COERCE1:%.*]], <vscale x 4 x i32> [[V_COERCE2:%.*]], <vscale x 4 x i32> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -769,8 +769,8 @@ void test_svstnt1_vnum_s32_x4(svcount_t pn, int32_t *base, int64_t vnum, svint32 // CHECK-LABEL: @test_svstnt1_vnum_s64_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -778,8 +778,8 @@ void test_svstnt1_vnum_s32_x4(svcount_t pn, int32_t *base, int64_t vnum, svint32 // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_s64_x4u11__SVCount_tPll11svint64x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2i64(<vscale x 2 x i64> [[V_COERCE0:%.*]], <vscale x 2 x i64> [[V_COERCE1:%.*]], <vscale x 2 x i64> [[V_COERCE2:%.*]], <vscale x 2 x i64> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -794,8 +794,8 @@ void test_svstnt1_vnum_s64_x4(svcount_t pn, int64_t *base, int64_t vnum, svint64 // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -804,8 +804,8 @@ void test_svstnt1_vnum_s64_x4(svcount_t pn, int64_t *base, int64_t vnum, svint64 // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -820,8 +820,8 @@ void test_svstnt1_vnum_f16_x2(svcount_t pn, float16_t *base, float64_t vnum, svf // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -830,8 +830,8 @@ void test_svstnt1_vnum_f16_x2(svcount_t pn, float16_t *base, float64_t vnum, svf // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -846,8 +846,8 @@ void test_svstnt1_vnum_f32_x2(svcount_t pn, float32_t *base, float64_t vnum, svf // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -856,8 +856,8 @@ void test_svstnt1_vnum_f32_x2(svcount_t pn, float32_t *base, float64_t vnum, svf // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -870,8 +870,8 @@ void test_svstnt1_vnum_f64_x2(svcount_t pn, float64_t *base, float64_t vnum, svf // CHECK-LABEL: @test_svstnt1_vnum_mf8_x2( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -879,8 +879,8 @@ void test_svstnt1_vnum_f64_x2(svcount_t pn, float64_t *base, float64_t vnum, svf // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_mf8_x2u11__SVCount_tPu6__mfp8l13svmfloat8x2_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x2.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -894,8 +894,8 @@ void test_svstnt1_vnum_mf8_x2(svcount_t pn, mfloat8_t *base, int64_t vnum, svmfl // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], <vscale x 8 x half> [[V_COERCE2:%.*]], <vscale x 8 x half> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -904,8 +904,8 @@ void test_svstnt1_vnum_mf8_x2(svcount_t pn, mfloat8_t *base, int64_t vnum, svmfl // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv8f16(<vscale x 8 x half> [[V_COERCE0:%.*]], <vscale x 8 x half> [[V_COERCE1:%.*]], <vscale x 8 x half> [[V_COERCE2:%.*]], <vscale x 8 x half> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -920,8 +920,8 @@ void test_svstnt1_vnum_f16_x4(svcount_t pn, float16_t *base, float64_t vnum, svf // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], <vscale x 4 x float> [[V_COERCE2:%.*]], <vscale x 4 x float> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -930,8 +930,8 @@ void test_svstnt1_vnum_f16_x4(svcount_t pn, float16_t *base, float64_t vnum, svf // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv4f32(<vscale x 4 x float> [[V_COERCE0:%.*]], <vscale x 4 x float> [[V_COERCE1:%.*]], <vscale x 4 x float> [[V_COERCE2:%.*]], <vscale x 4 x float> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -946,8 +946,8 @@ void test_svstnt1_vnum_f32_x4(svcount_t pn, float32_t *base, float64_t vnum, svf // CHECK-NEXT: entry: // CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], <vscale x 2 x double> [[V_COERCE2:%.*]], <vscale x 2 x double> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -956,8 +956,8 @@ void test_svstnt1_vnum_f32_x4(svcount_t pn, float32_t *base, float64_t vnum, svf // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[CONV:%.*]] = fptosi double [[VNUM:%.*]] to i64 // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[CONV]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[CONV]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv2f64(<vscale x 2 x double> [[V_COERCE0:%.*]], <vscale x 2 x double> [[V_COERCE1:%.*]], <vscale x 2 x double> [[V_COERCE2:%.*]], <vscale x 2 x double> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void @@ -970,8 +970,8 @@ void test_svstnt1_vnum_f64_x4(svcount_t pn, float64_t *base, float64_t vnum, svf // CHECK-LABEL: @test_svstnt1_vnum_mf8_x4( // CHECK-NEXT: entry: // CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CHECK-NEXT: ret void @@ -979,8 +979,8 @@ void test_svstnt1_vnum_f64_x4(svcount_t pn, float64_t *base, float64_t vnum, svf // CPP-CHECK-LABEL: @_Z24test_svstnt1_vnum_mf8_x4u11__SVCount_tPu6__mfp8l13svmfloat8x4_t( // CPP-CHECK-NEXT: entry: // CPP-CHECK-NEXT: [[TMP0:%.*]] = tail call i64 @llvm.vscale.i64() -// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[VNUM:%.*]], 4 -// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[TMP0]] +// CPP-CHECK-NEXT: [[TMP1:%.*]] = shl nuw nsw i64 [[TMP0]], 4 +// CPP-CHECK-NEXT: [[DOTIDX:%.*]] = mul i64 [[TMP1]], [[VNUM:%.*]] // CPP-CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[BASE:%.*]], i64 [[DOTIDX]] // CPP-CHECK-NEXT: tail call void @llvm.aarch64.sve.stnt1.pn.x4.nxv16i8(<vscale x 16 x i8> [[V_COERCE0:%.*]], <vscale x 16 x i8> [[V_COERCE1:%.*]], <vscale x 16 x i8> [[V_COERCE2:%.*]], <vscale x 16 x i8> [[V_COERCE3:%.*]], target("aarch64.svcount") [[PN:%.*]], ptr [[TMP2]]) // CPP-CHECK-NEXT: ret void 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/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..43d9a63 --- /dev/null +++ b/clang/test/CodeGen/alloc-token-lower.c @@ -0,0 +1,34 @@ +// 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 2689373973731826898){{.*}} !alloc_token [[META_INT:![0-9]+]] +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)); +} + +// By default, we should not be touching malloc-attributed non-libcall +// functions: there might be an arbitrary number of these, and a compatible +// allocator will only implement standard allocation functions. +void *nonstandard_malloc(size_t size) __attribute__((malloc)); +// CHECK-LABEL: @test_nonlibcall_malloc( +// CHECK: call{{.*}} ptr @nonstandard_malloc(i64 noundef 4){{.*}} !alloc_token [[META_INT]] +void *test_nonlibcall_malloc() { + return nonstandard_malloc(sizeof(int)); +} + +// CHECK: [[META_INT]] = !{!"int", i1 false} diff --git a/clang/test/CodeGen/alloc-token-nonlibcalls.c b/clang/test/CodeGen/alloc-token-nonlibcalls.c new file mode 100644 index 0000000..da81bec --- /dev/null +++ b/clang/test/CodeGen/alloc-token-nonlibcalls.c @@ -0,0 +1,23 @@ +// RUN: %clang_cc1 -fsanitize=alloc-token -fsanitize-alloc-token-extended -triple x86_64-linux-gnu -emit-llvm -disable-llvm-passes %s -o - | FileCheck --check-prefixes=CHECK,CHECK-CODEGEN %s +// RUN: %clang_cc1 -fsanitize=alloc-token -fsanitize-alloc-token-extended -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck --check-prefixes=CHECK,CHECK-LOWER %s +// RUN: %clang_cc1 -O -fsanitize=alloc-token -fsanitize-alloc-token-extended -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck --check-prefixes=CHECK,CHECK-LOWER %s + +typedef __typeof(sizeof(int)) size_t; +typedef size_t gfp_t; + +void *custom_malloc(size_t size) __attribute__((malloc)); +void *__kmalloc(size_t size, gfp_t flags) __attribute__((alloc_size(1))); + +void *sink; + +// CHECK-LABEL: @test_nonlibcall_alloc( +// CHECK-CODEGEN: call noalias ptr @custom_malloc(i64 noundef 4){{.*}} !alloc_token [[META_INT:![0-9]+]] +// CHECK-CODEGEN: call ptr @__kmalloc(i64 noundef 4, i64 noundef 0){{.*}} !alloc_token [[META_INT]] +// CHECK-LOWER: call{{.*}} noalias ptr @__alloc_token_custom_malloc(i64 noundef 4, i64 2689373973731826898){{.*}} !alloc_token [[META_INT:![0-9]+]] +// CHECK-LOWER: call{{.*}} ptr @__alloc_token___kmalloc(i64 noundef 4, i64 noundef 0, i64 2689373973731826898){{.*}} !alloc_token [[META_INT]] +void test_nonlibcall_alloc() { + sink = custom_malloc(sizeof(int)); + sink = __kmalloc(sizeof(int), 0); +} + +// CHECK: [[META_INT]] = !{!"int", i1 false} diff --git a/clang/test/CodeGen/alloc-token.c b/clang/test/CodeGen/alloc-token.c new file mode 100644 index 0000000..3c9b4d8 --- /dev/null +++ b/clang/test/CodeGen/alloc-token.c @@ -0,0 +1,40 @@ +// 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) __attribute__((malloc)); +void *malloc(size_t size) __attribute__((malloc)); +void *calloc(size_t num, size_t size) __attribute__((malloc)); +void *realloc(void *ptr, size_t size) __attribute__((malloc)); +void *reallocarray(void *ptr, size_t nmemb, size_t size) __attribute__((malloc)); +void *memalign(size_t alignment, size_t size) __attribute__((malloc)); +void *valloc(size_t size) __attribute__((malloc)); +void *pvalloc(size_t size) __attribute__((malloc)); +int posix_memalign(void **memptr, size_t alignment, size_t size); + +void *sink; + +// CHECK-LABEL: define dso_local void @test_malloc_like( +// CHECK: call noalias ptr @malloc(i64 noundef 4){{.*}} !alloc_token [[META_INT:![0-9]+]] +// CHECK: call noalias ptr @calloc(i64 noundef 3, i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias ptr @realloc(ptr noundef {{.*}}, i64 noundef 8){{.*}} !alloc_token [[META_LONG:![0-9]+]] +// CHECK: call noalias ptr @reallocarray(ptr noundef {{.*}}, i64 noundef 5, i64 noundef 8), !alloc_token [[META_LONG]] +// CHECK: call noalias align 128 ptr @aligned_alloc(i64 noundef 128, i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias align 16 ptr @memalign(i64 noundef 16, i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias ptr @valloc(i64 noundef 4), !alloc_token [[META_INT]] +// CHECK: call noalias ptr @pvalloc(i64 noundef 4), !alloc_token [[META_INT]] +// 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, sizeof(int)); + sink = memalign(16, sizeof(int)); + sink = valloc(sizeof(int)); + sink = pvalloc(sizeof(int)); + posix_memalign(&sink, 64, sizeof(int)); // FIXME: support posix_memalign +} + +// CHECK: [[META_INT]] = !{!"int", i1 false} +// CHECK: [[META_LONG]] = !{!"long", i1 false} 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-pointer.cpp b/clang/test/CodeGenCXX/alloc-token-pointer.cpp new file mode 100644 index 0000000..f12ee7a --- /dev/null +++ b/clang/test/CodeGenCXX/alloc-token-pointer.cpp @@ -0,0 +1,197 @@ +// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -std=c++20 -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s + +#include "../Analysis/Inputs/system-header-simulator-cxx.h" + +typedef __UINTPTR_TYPE__ uintptr_t; + +extern "C" { +void *malloc(size_t size) __attribute__((malloc)); +} + +void *sink; // prevent optimizations from removing the calls + +// CHECK-LABEL: define dso_local noundef ptr @_Z15test_malloc_intv( +// CHECK: call noalias ptr @malloc(i64 noundef 4){{.*}} !alloc_token [[META_INT:![0-9]+]] +void *test_malloc_int() { + int *a = (int *)malloc(sizeof(int)); + *a = 42; + return a; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z15test_malloc_ptrv( +// CHECK: call noalias ptr @malloc(i64 noundef 8){{.*}} !alloc_token [[META_INTPTR:![0-9]+]] +int **test_malloc_ptr() { + int **a = (int **)malloc(sizeof(int*)); + *a = nullptr; + return a; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z12test_new_intv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4){{.*}} !alloc_token [[META_INT]] +int *test_new_int() { + return new int; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z20test_new_ulong_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 80){{.*}} !alloc_token [[META_ULONG:![0-9]+]] +unsigned long *test_new_ulong_array() { + return new unsigned long[10]; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z12test_new_ptrv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 8){{.*}} !alloc_token [[META_INTPTR]] +int **test_new_ptr() { + return new int*; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z18test_new_ptr_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 80){{.*}} !alloc_token [[META_INTPTR]] +int **test_new_ptr_array() { + return new int*[10]; +} + +struct ContainsPtr { + int a; + char *buf; +}; + +// CHECK-LABEL: define dso_local noundef ptr @_Z27test_malloc_struct_with_ptrv( +// CHECK: call noalias ptr @malloc(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR:![0-9]+]] +void *test_malloc_struct_with_ptr() { + return malloc(sizeof(ContainsPtr)); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z33test_malloc_struct_array_with_ptrv( +// CHECK: call noalias ptr @malloc(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +void *test_malloc_struct_array_with_ptr() { + return malloc(10 * sizeof(ContainsPtr)); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z31test_malloc_with_ptr_sizeof_vari( +// CHECK: call noalias ptr @malloc(i64 noundef {{.*}}){{.*}} !alloc_token [[META_CONTAINSPTR]] +void *test_malloc_with_ptr_sizeof_var(int x) { + unsigned long size = sizeof(ContainsPtr); + size *= x; + return malloc(size); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z29test_malloc_with_ptr_castonlyv( +// CHECK: call noalias ptr @malloc(i64 noundef 4096){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_malloc_with_ptr_castonly() { + return (ContainsPtr *)malloc(4096); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z32test_operatornew_struct_with_ptrv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR]] +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_operatornew_struct_with_ptr() { + ContainsPtr *c = (ContainsPtr *)__builtin_operator_new(sizeof(ContainsPtr)); + sink = ::operator new(sizeof(ContainsPtr)); + return c; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z38test_operatornew_struct_array_with_ptrv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_operatornew_struct_array_with_ptr() { + ContainsPtr *c = (ContainsPtr *)__builtin_operator_new(10 * sizeof(ContainsPtr)); + sink = ::operator new(10 * sizeof(ContainsPtr)); + return c; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z33test_operatornew_struct_with_ptr2v( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR]] +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_operatornew_struct_with_ptr2() { + ContainsPtr *c = (ContainsPtr *)__builtin_operator_new(sizeof(*c)); + sink = ::operator new(sizeof(*c)); + return c; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z39test_operatornew_struct_array_with_ptr2v( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_operatornew_struct_array_with_ptr2() { + ContainsPtr *c = (ContainsPtr *)__builtin_operator_new(10 * sizeof(*c)); + sink = ::operator new(10 * sizeof(*c)); + return c; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z24test_new_struct_with_ptrv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_new_struct_with_ptr() { + return new ContainsPtr; +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z30test_new_struct_array_with_ptrv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 160){{.*}} !alloc_token [[META_CONTAINSPTR]] +ContainsPtr *test_new_struct_array_with_ptr() { + return new ContainsPtr[10]; +} + +class TestClass { +public: + void Foo(); + ~TestClass(); + int data[16]; +}; + +// CHECK-LABEL: define dso_local noundef ptr @_Z14test_new_classv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 64){{.*}} !alloc_token [[META_TESTCLASS:![0-9]+]] +TestClass *test_new_class() { + return new TestClass(); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z20test_new_class_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 648){{.*}} !alloc_token [[META_TESTCLASS]] +TestClass *test_new_class_array() { + return new TestClass[10]; +} + +// Test that we detect that virtual classes have implicit vtable pointer. +class VirtualTestClass { +public: + virtual void Foo(); + virtual ~VirtualTestClass(); + int data[16]; +}; + +// CHECK-LABEL: define dso_local noundef ptr @_Z22test_new_virtual_classv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 72){{.*}} !alloc_token [[META_VIRTUALTESTCLASS:![0-9]+]] +VirtualTestClass *test_new_virtual_class() { + return new VirtualTestClass(); +} + +// CHECK-LABEL: define dso_local noundef ptr @_Z28test_new_virtual_class_arrayv( +// CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 728){{.*}} !alloc_token [[META_VIRTUALTESTCLASS]] +VirtualTestClass *test_new_virtual_class_array() { + return new VirtualTestClass[10]; +} + +// uintptr_t is treated as a pointer. +struct MyStructUintptr { + int a; + uintptr_t ptr; +}; + +// CHECK-LABEL: define dso_local noundef ptr @_Z18test_uintptr_isptrv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 16){{.*}} !alloc_token [[META_MYSTRUCTUINTPTR:![0-9]+]] +MyStructUintptr *test_uintptr_isptr() { + return new MyStructUintptr; +} + +using uptr = uintptr_t; +// CHECK-LABEL: define dso_local noundef ptr @_Z19test_uintptr_isptr2v( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 8){{.*}} !alloc_token [[META_UINTPTR:![0-9]+]] +uptr *test_uintptr_isptr2() { + return new uptr; +} + +// CHECK: [[META_INT]] = !{!"int", i1 false} +// CHECK: [[META_INTPTR]] = !{!"int *", i1 true} +// CHECK: [[META_ULONG]] = !{!"unsigned long", i1 false} +// CHECK: [[META_CONTAINSPTR]] = !{!"ContainsPtr", i1 true} +// CHECK: [[META_TESTCLASS]] = !{!"TestClass", i1 false} +// CHECK: [[META_VIRTUALTESTCLASS]] = !{!"VirtualTestClass", i1 true} +// CHECK: [[META_MYSTRUCTUINTPTR]] = !{!"MyStructUintptr", i1 true} +// CHECK: [[META_UINTPTR]] = !{!"unsigned long", i1 true} diff --git a/clang/test/CodeGenCXX/alloc-token.cpp b/clang/test/CodeGenCXX/alloc-token.cpp new file mode 100644 index 0000000..feed808 --- /dev/null +++ b/clang/test/CodeGenCXX/alloc-token.cpp @@ -0,0 +1,156 @@ +// 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) __attribute__((malloc)); +void *malloc(size_t size) __attribute__((malloc)); +void *calloc(size_t num, size_t size) __attribute__((malloc)); +void *realloc(void *ptr, size_t size) __attribute__((malloc)); +void *reallocarray(void *ptr, size_t nmemb, size_t size) __attribute__((malloc)); +void *memalign(size_t alignment, size_t size) __attribute__((malloc)); +void *valloc(size_t size) __attribute__((malloc)); +void *pvalloc(size_t size) __attribute__((malloc)); +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 noalias ptr @malloc(i64 noundef 4){{.*}} !alloc_token [[META_INT:![0-9]+]] +// CHECK: call noalias ptr @calloc(i64 noundef 3, i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias ptr @realloc(ptr noundef {{.*}}, i64 noundef 8){{.*}} !alloc_token [[META_LONG:![0-9]+]] +// CHECK: call noalias ptr @reallocarray(ptr noundef {{.*}}, i64 noundef 5, i64 noundef 8), !alloc_token [[META_LONG]] +// CHECK: call noalias align 128 ptr @aligned_alloc(i64 noundef 128, i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias ptr @memalign(i64 noundef 16, i64 noundef 4), !alloc_token [[META_INT]] +// CHECK: call noalias ptr @valloc(i64 noundef 4), !alloc_token [[META_INT]] +// CHECK: call noalias ptr @pvalloc(i64 noundef 4), !alloc_token [[META_INT]] +// 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, sizeof(int)); + sink = memalign(16, sizeof(int)); + sink = valloc(sizeof(int)); + sink = pvalloc(sizeof(int)); + posix_memalign(&sink, 64, sizeof(int)); // FIXME: support posix_memalign +} + +class ForwardDecl; + +// CHECK-LABEL: define dso_local void @_Z21test_malloc_like_castv( +// CHECK: call noalias ptr @malloc(i64 noundef 64){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias ptr @malloc(i64 noundef 64){{.*}} !alloc_token [[META_INT]] +// CHECK-NOT: call noalias ptr @malloc(i64 noundef 64){{.*}} !alloc_token [[META_INT]] +void test_malloc_like_cast() { + sink = (int *)malloc(64); + sink = reinterpret_cast<int *>(malloc(64)); + // Always fails to assign token ID for incomplete types. + sink = reinterpret_cast<ForwardDecl *>(malloc(64)); +} + +// CHECK-LABEL: define dso_local void @_Z17test_operator_newv( +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4){{.*}} !alloc_token [[META_INT]] +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){{.*}} !alloc_token [[META_INT]] +// CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t(i64 noundef 4, ptr noundef nonnull align 1 dereferenceable(1) @_ZSt7nothrow){{.*}} !alloc_token [[META_INT]] +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]] +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() { + // FIXME: Support __size_returning_new variants. + 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", i1 false} +// CHECK: [[META_LONG]] = !{!"long", i1 false} +// CHECK: [[META_TESTCLASS]] = !{!"TestClass", i1 true} diff --git a/clang/test/CodeGenCXX/template-cxx20.cpp b/clang/test/CodeGenCXX/template-cxx20.cpp new file mode 100644 index 0000000..aeb1cc9 --- /dev/null +++ b/clang/test/CodeGenCXX/template-cxx20.cpp @@ -0,0 +1,24 @@ +// RUN: %clang_cc1 %s -O0 -disable-llvm-passes -triple=x86_64 -std=c++20 -emit-llvm -o - | FileCheck %s + +namespace GH161029_regression1 { + template <class _Fp> auto f(int) { _Fp{}(0); } + template <class _Fp, int... _Js> void g() { + (..., f<_Fp>(_Js)); + } + enum E { k }; + template <int, E> struct ElementAt; + template <E First> struct ElementAt<0, First> { + static int value; + }; + template <typename T, T Item> struct TagSet { + template <int Index> using Tag = ElementAt<Index, Item>; + }; + template <typename TagSet> struct S { + void U() { (void)TagSet::template Tag<0>::value; } + }; + S<TagSet<E, k>> s; + void h() { + g<decltype([](auto) -> void { s.U(); }), 0>(); + } + // CHECK: call void @_ZN20GH161029_regression11SINS_6TagSetINS_1EELS2_0EEEE1UEv +} diff --git a/clang/test/CodeGenHLSL/resources/StructuredBuffers-constructors.hlsl b/clang/test/CodeGenHLSL/resources/StructuredBuffers-constructors.hlsl index 89a66b0..96c2d95 100644 --- a/clang/test/CodeGenHLSL/resources/StructuredBuffers-constructors.hlsl +++ b/clang/test/CodeGenHLSL/resources/StructuredBuffers-constructors.hlsl @@ -1,8 +1,7 @@ // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -emit-llvm -disable-llvm-passes -o - %s | \ // RUN: llvm-cxxfilt | FileCheck %s --check-prefixes=CHECK,CHECK-DXIL -// FIXME: SPIR-V codegen of llvm.spv.resource.handlefrombinding and resource types is not yet implemented -// RUN-DISABLED: %clang_cc1 -triple spirv-vulkan-library -x hlsl -emit-llvm -disable-llvm-passes -o - %s | \ -// llvm-cxxfilt | FileCheck %s --check-prefixes=CHECK,CHECK-SPIRV +// RUN: %clang_cc1 -triple spirv-vulkan-library -x hlsl -emit-llvm -disable-llvm-passes -o - %s | \ +// RUN: llvm-cxxfilt | FileCheck %s --check-prefixes=CHECK,CHECK-SPV // NOTE: Itanium ABI for C++ requires Clang to generate 2 constructors types to support polymorphism: // - C1 - Complete object constructor - constructs the complete object, including virtual base classes. @@ -24,52 +23,65 @@ export void foo() { // CHECK-DXIL: %"class.hlsl::RWStructuredBuffer" = type { target("dx.RawBuffer", float, 1, 0), target("dx.RawBuffer", float, 1, 0) } // CHECK-DXIL: %"class.hlsl::AppendStructuredBuffer" = type { target("dx.RawBuffer", float, 1, 0), target("dx.RawBuffer", float, 1, 0) } -// CHECK: @Buf1 = internal global %"class.hlsl::StructuredBuffer" poison, align 4 +// CHECK: @Buf1 = internal global %"class.hlsl::StructuredBuffer" poison // CHECK: @[[Buf1Str:.*]] = private unnamed_addr constant [5 x i8] c"Buf1\00", align 1 -// CHECK: @Buf2 = internal global %"class.hlsl::RWStructuredBuffer" poison, align 4 +// CHECK: @Buf2 = internal global %"class.hlsl::RWStructuredBuffer" poison // CHECK: @[[Buf2Str:.*]] = private unnamed_addr constant [5 x i8] c"Buf2\00", align 1 // Buf1 initialization part 1 - global init function that calls StructuredBuffer<float>::__createFromBinding // with explicit binding -// CHECK: define internal void @__cxx_global_var_init() +// CHECK: define internal {{.*}}void @__cxx_global_var_init() // CHECK-NEXT: entry: -// CHECK-NEXT: call void @hlsl::StructuredBuffer<float>::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) +// CHECK: call void @hlsl::StructuredBuffer<float>::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) // CHECK-SAME: (ptr {{.*}} @Buf1, i32 noundef 10, i32 noundef 2, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf1Str]]) // Buf1 initialization part 2 - body of StructuredBuffer<float>::::__createFromBinding // CHECK: define {{.*}} void @hlsl::StructuredBuffer<float>::__createFromBinding(unsigned int, unsigned int, int, unsigned int, char const*) -// CHECK-SAME: ptr {{.*}} sret(%"class.hlsl::StructuredBuffer") align 4 %[[RetValue1:.*]], i32 noundef %registerNo, +// CHECK-SAME: ptr {{.*}} sret(%"class.hlsl::StructuredBuffer") align {{(4|8)}} %[[RetValue1:.*]], i32 noundef %registerNo, // CHECK-SAME: i32 noundef %spaceNo, i32 noundef %range, i32 noundef %index, ptr noundef %name) -// CHECK: %[[Tmp1:.*]] = alloca %"class.hlsl::StructuredBuffer", align 4 +// CHECK: %[[Tmp1:.*]] = alloca %"class.hlsl::StructuredBuffer" // CHECK-DXIL: %[[Handle1:.*]] = call target("dx.RawBuffer", float, 0, 0) // CHECK-DXIL-SAME: @llvm.dx.resource.handlefrombinding.tdx.RawBuffer_f32_0_0t( // CHECK: %__handle = getelementptr inbounds nuw %"class.hlsl::StructuredBuffer", ptr %[[Tmp1]], i32 0, i32 0 // CHECK-DXIL: store target("dx.RawBuffer", float, 0, 0) %[[Handle1]], ptr %__handle, align 4 // CHECK: call void @hlsl::StructuredBuffer<float>::StructuredBuffer(hlsl::StructuredBuffer<float> const&)(ptr {{.*}} %[[RetValue1]], ptr {{.*}} %[[Tmp1]]) -// Buf2 initialization part 1 - global init function that calls RWStructuredBuffer<float>::__createFromImplicitBinding -// CHECK: define internal void @__cxx_global_var_init.1() +// Buf2 initialization part 1 - global init function that calls RWStructuredBuffer<float>::__createFromImplicitBindingWithImplicitCounter +// CHECK: define internal {{.*}}void @__cxx_global_var_init.1() // CHECK-NEXT: entry: -// CHECK-NEXT: call void @hlsl::RWStructuredBuffer<float>::__createFromImplicitBinding(unsigned int, unsigned int, int, unsigned int, char const*) -// CHECK-SAME: (ptr {{.*}} @Buf2, i32 noundef 0, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf2Str]]) +// CHECK: call void @hlsl::RWStructuredBuffer<float>::__createFromImplicitBindingWithImplicitCounter(unsigned int, unsigned int, int, unsigned int, char const*, unsigned int) +// CHECK-SAME: (ptr {{.*}} @Buf2, i32 noundef 0, i32 noundef 0, i32 noundef 1, i32 noundef 0, ptr noundef @[[Buf2Str]], i32 noundef 1) -// Buf2 initialization part 2 - body of RWStructuredBuffer<float>::__createFromImplicitBinding -// CHECK: define linkonce_odr hidden void @hlsl::RWStructuredBuffer<float>::__createFromImplicitBinding(unsigned int, unsigned int, int, unsigned int, char const*) -// CHECK-SAME: (ptr {{.*}} sret(%"class.hlsl::RWStructuredBuffer") align 4 %[[RetValue2:.*]], i32 noundef %orderId, -// CHECK-SAME: i32 noundef %spaceNo, i32 noundef %range, i32 noundef %index, ptr noundef %name) -// CHECK: %[[Tmp2:.*]] = alloca %"class.hlsl::RWStructuredBuffer", align 4 +// Buf2 initialization part 2 - body of RWStructuredBuffer<float>::__createFromImplicitBindingWithImplicitCounter +// CHECK: define linkonce_odr hidden void @hlsl::RWStructuredBuffer<float>::__createFromImplicitBindingWithImplicitCounter(unsigned int, unsigned int, int, unsigned int, char const*, unsigned int) +// CHECK-SAME: (ptr {{.*}} sret(%"class.hlsl::RWStructuredBuffer") align {{(4|8)}} %[[RetValue2:.*]], i32 noundef %orderId, +// CHECK-SAME: i32 noundef %spaceNo, i32 noundef %range, i32 noundef %index, ptr noundef %name, i32 noundef %counterOrderId) +// CHECK: %[[Tmp2:.*]] = alloca %"class.hlsl::RWStructuredBuffer" // CHECK-DXIL: %[[Handle2:.*]] = call target("dx.RawBuffer", float, 1, 0) // CHECK-DXIL-SAME: @llvm.dx.resource.handlefromimplicitbinding.tdx.RawBuffer_f32_1_0t( -// CHECK: %__handle = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 0 -// CHECK-DXIL: store target("dx.RawBuffer", float, 1, 0) %[[Handle2]], ptr %__handle, align 4 +// CHECK-DXIL: %[[HandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 0 +// CHECK-DXIL-NEXT: store target("dx.RawBuffer", float, 1, 0) %[[Handle2]], ptr %[[HandlePtr]], align 4 +// CHECK-DXIL: %[[HandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 0 +// CHECK-DXIL: %[[LoadedHandle:.*]] = load target("dx.RawBuffer", float, 1, 0), ptr %[[HandlePtr]], align 4 +// CHECK-DXIL: %[[CounterHandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 1 +// CHECK-DXIL-NEXT: store target("dx.RawBuffer", float, 1, 0) %[[LoadedHandle]], ptr %[[CounterHandlePtr]], align 4 +// CHECK-SPV: %[[Handle2:.*]] = call target("spirv.VulkanBuffer", [0 x float], 12, 1) +// CHECK-SPV-SAME: @llvm.spv.resource.handlefromimplicitbinding.tspirv.VulkanBuffer_a0f32_12_1t( +// CHECK-SPV: %[[HandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 0 +// CHECK-SPV-NEXT: store target("spirv.VulkanBuffer", [0 x float], 12, 1) %[[Handle2]], ptr %[[HandlePtr]], align 8 +// CHECK-SPV: %[[HandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 0 +// CHECK-SPV: %[[LoadedHandle:.*]] = load target("spirv.VulkanBuffer", [0 x float], 12, 1), ptr %[[HandlePtr]], align 8 +// CHECK-SPV: %[[CounterHandle:.*]] = call target("spirv.VulkanBuffer", i32, 12, 1) @llvm.spv.resource.counterhandlefromimplicitbinding +// CHECK-SPV: %[[CounterHandlePtr:.*]] = getelementptr inbounds nuw %"class.hlsl::RWStructuredBuffer", ptr %[[Tmp2]], i32 0, i32 1 +// CHECK-SPV-NEXT: store target("spirv.VulkanBuffer", i32, 12, 1) %[[CounterHandle]], ptr %[[CounterHandlePtr]], align 8 // CHECK: call void @hlsl::RWStructuredBuffer<float>::RWStructuredBuffer(hlsl::RWStructuredBuffer<float> const&)(ptr {{.*}} %[[RetValue2]], ptr {{.*}} %[[Tmp2]]) // Buf3 initialization part 1 - local variable declared in function foo() is initialized by // AppendStructuredBuffer<float> C1 default constructor -// CHECK: define void @foo() +// CHECK: define {{.*}}void @foo() // CHECK-NEXT: entry: -// CHECK-NEXT: %Buf3 = alloca %"class.hlsl::AppendStructuredBuffer", align 4 +// CHECK: %Buf3 = alloca %"class.hlsl::AppendStructuredBuffer", align {{4|8}} // CHECK-NEXT: call void @hlsl::AppendStructuredBuffer<float>::AppendStructuredBuffer()(ptr {{.*}} %Buf3) // Buf3 initialization part 2 - body of AppendStructuredBuffer<float> default C1 constructor that calls @@ -84,7 +96,7 @@ export void foo() { // CHECK-DXIL: store target("dx.RawBuffer", float, 1, 0) poison, ptr %__handle, align 4 // Module initialization -// CHECK: define internal void @_GLOBAL__sub_I_StructuredBuffers_constructors.hlsl() +// CHECK: define internal {{.*}}void @_GLOBAL__sub_I_StructuredBuffers_constructors.hlsl() // CHECK-NEXT: entry: -// CHECK-NEXT: call void @__cxx_global_var_init() -// CHECK-NEXT: call void @__cxx_global_var_init.1() +// CHECK: call {{.*}}void @__cxx_global_var_init() +// CHECK-NEXT: call {{.*}}void @__cxx_global_var_init.1() diff --git a/clang/test/CodeGenHLSL/resources/res-array-rw-counter.hlsl b/clang/test/CodeGenHLSL/resources/res-array-rw-counter.hlsl new file mode 100644 index 0000000..c3d5784 --- /dev/null +++ b/clang/test/CodeGenHLSL/resources/res-array-rw-counter.hlsl @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-DXIL +// RUN: %clang_cc1 -triple spirv-vulkan-library -x hlsl -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-SPV + +// CHECK-DXIL: %"class.hlsl::RWStructuredBuffer" = type { target("dx.RawBuffer", float, 1, 0), target("dx.RawBuffer", float, 1, 0) } +// CHECK-SPV: %"class.hlsl::RWStructuredBuffer" = type { target("spirv.VulkanBuffer", [0 x float], 12, 1), target("spirv.VulkanBuffer", i32, 12, 1) } + +RWStructuredBuffer<float> BufArray[4]; + +export void foo(int idx) { + BufArray[0].IncrementCounter(); + BufArray[idx].DecrementCounter(); +} + +// CHECK: @[[BufArrayStr:.*]] = private unnamed_addr constant [9 x i8] c"BufArray\00", align 1 + +// CHECK: define {{.*}}void @_Z3fooi(i32 noundef %[[IDX_ARG:.*]]) +// CHECK-NEXT: entry: +// CHECK: %[[IDX_ADDR:.*]] = alloca i32 +// CHECK: [[TMP_INC:%.*]] = alloca %"class.hlsl::RWStructuredBuffer" +// CHECK: [[TMP_DEC:%.*]] = alloca %"class.hlsl::RWStructuredBuffer" +// CHECK: store i32 %[[IDX_ARG]], ptr %[[IDX_ADDR]] +// CHECK: call void @_ZN4hlsl18RWStructuredBufferIfE46__createFromImplicitBindingWithImplicitCounterEjjijPKcj(ptr {{.*}} [[TMP_INC]], i32 noundef 0, i32 noundef 0, i32 noundef 4, i32 noundef 0, ptr noundef @[[BufArrayStr]], i32 noundef 1) +// CHECK: call noundef i32 @_ZN4hlsl18RWStructuredBufferIfE16IncrementCounterEv(ptr {{.*}} [[TMP_INC]]) +// CHECK: %[[IDX_LOADED:.*]] = load i32, ptr %[[IDX_ADDR]] +// CHECK: call void @_ZN4hlsl18RWStructuredBufferIfE46__createFromImplicitBindingWithImplicitCounterEjjijPKcj(ptr {{.*}} [[TMP_DEC]], i32 noundef 0, i32 noundef 0, i32 noundef 4, i32 noundef %[[IDX_LOADED]], ptr noundef @[[BufArrayStr]], i32 noundef 1) +// CHECK: call noundef i32 @_ZN4hlsl18RWStructuredBufferIfE16DecrementCounterEv(ptr {{.*}} [[TMP_DEC]])
\ No newline at end of file diff --git a/clang/test/CodeGenHLSL/vk_binding_attr.hlsl b/clang/test/CodeGenHLSL/vk_binding_attr.hlsl index bbef051..45955e1 100644 --- a/clang/test/CodeGenHLSL/vk_binding_attr.hlsl +++ b/clang/test/CodeGenHLSL/vk_binding_attr.hlsl @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple spirv-unknown-vulkan1.3-library -finclude-default-header -O3 -emit-llvm -o - %s | FileCheck %s +// RUN: %clang_cc1 -triple spirv-unknown-vulkan1.3-compute -finclude-default-header -O3 -emit-llvm -o - %s | FileCheck %s // CHECK: [[Buf:@.*]] = private unnamed_addr constant [4 x i8] c"Buf\00" // CHECK: [[Buf2:@.*]] = private unnamed_addr constant [5 x i8] c"Buf2\00" // CHECK: [[Buf3:@.*]] = private unnamed_addr constant [5 x i8] c"Buf3\00" diff --git a/clang/test/CodeGenOpenCL/builtins.cl b/clang/test/CodeGenOpenCL/builtins.cl index aa666c7..708d1b8 100644 --- a/clang/test/CodeGenOpenCL/builtins.cl +++ b/clang/test/CodeGenOpenCL/builtins.cl @@ -62,19 +62,19 @@ void testBranchingOnAddressSpaceCast(generic long* ptr) { if (to_global(ptr)) (void)0; // CHECK: [[P:%[0-9]+]] = call spir_func [[GLOBAL_VOID:ptr addrspace\(1\)]] @__to_global([[GENERIC_VOID:ptr addrspace\(4\)]] {{%[0-9]+}}) - // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr addrspace(1) [[P]], null + // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr addrspace(1) [[P]], addrspacecast (ptr addrspace(4) null to ptr addrspace(1)) // CHECK-NEXT: br i1 [[BOOL]] if (to_local(ptr)) (void)0; // CHECK: [[P:%[0-9]+]] = call spir_func [[LOCAL_VOID:ptr addrspace\(3\)]] @__to_local([[GENERIC_VOID]] {{%[0-9]+}}) - // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr addrspace(3) [[P]], null + // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr addrspace(3) [[P]], addrspacecast (ptr addrspace(4) null to ptr addrspace(3)) // CHECK-NEXT: br i1 [[BOOL]] if (to_private(ptr)) (void)0; // CHECK: [[P:%[0-9]+]] = call spir_func [[PRIVATE_VOID:ptr]] @__to_private([[GENERIC_VOID]] {{%[0-9]+}}) - // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr [[P]], null + // CHECK-NEXT: [[BOOL:%[a-z0-9]+]] = icmp ne ptr [[P]], addrspacecast (ptr addrspace(4) null to ptr) // CHECK-NEXT: br i1 [[BOOL]] } diff --git a/clang/test/CodeGenSYCL/address-space-conversions.cpp b/clang/test/CodeGenSYCL/address-space-conversions.cpp index fa7acb0..ea52be5 100644 --- a/clang/test/CodeGenSYCL/address-space-conversions.cpp +++ b/clang/test/CodeGenSYCL/address-space-conversions.cpp @@ -35,9 +35,9 @@ void tmpl(T t) {} // CHECK-DAG: [[LOC]].ascast = addrspacecast ptr [[LOC]] to ptr addrspace(4) // CHECK-DAG: [[PRIV]].ascast = addrspacecast ptr [[PRIV]] to ptr addrspace(4) LOC = nullptr; - // CHECK-DAG: store ptr addrspace(3) null, ptr addrspace(4) [[LOC]].ascast, align 8 + // CHECK-DAG: store ptr addrspace(3) addrspacecast (ptr addrspace(4) null to ptr addrspace(3)), ptr addrspace(4) [[LOC]].ascast, align 8 GLOB = nullptr; - // CHECK-DAG: store ptr addrspace(1) null, ptr addrspace(4) [[GLOB]].ascast, align 8 + // CHECK-DAG: store ptr addrspace(1) addrspacecast (ptr addrspace(4) null to ptr addrspace(1)), ptr addrspace(4) [[GLOB]].ascast, align 8 // Explicit conversions // From named address spaces to default address space diff --git a/clang/test/DebugInfo/AArch64/sve-vector-types.c b/clang/test/DebugInfo/AArch64/sve-vector-types.c index ca592b1..ed1dbd1 100644 --- a/clang/test/DebugInfo/AArch64/sve-vector-types.c +++ b/clang/test/DebugInfo/AArch64/sve-vector-types.c @@ -3,10 +3,10 @@ void test_locals(void) { // CHECK-DAG: name: "__SVBool_t",{{.*}}, baseType: ![[CT1:[0-9]+]] - // CHECK-DAG: ![[CT1]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTYU8:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS1_64:[0-9]+]]) + // CHECK-DAG: ![[CT1]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTYU8:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS8:[0-9]+]], bitStride: i64 1) // CHECK-DAG: ![[ELTTYU8]] = !DIBasicType(name: "unsigned char", size: 8, encoding: DW_ATE_unsigned_char) - // CHECK-DAG: ![[ELTS1_64]] = !{![[REALELTS1_64:[0-9]+]]} - // CHECK-DAG: ![[REALELTS1_64]] = !DISubrange(lowerBound: 0, upperBound: !DIExpression(DW_OP_constu, 1, DW_OP_bregx, 46, 0, DW_OP_mul, DW_OP_constu, 1, DW_OP_minus)) + // CHECK-DAG: ![[ELTS8]] = !{![[REALELTS8:[0-9]+]]} + // CHECK-DAG: ![[REALELTS8]] = !DISubrange(lowerBound: 0, upperBound: !DIExpression(DW_OP_constu, 8, DW_OP_bregx, 46, 0, DW_OP_mul, DW_OP_constu, 1, DW_OP_minus)) __SVBool_t b8; // CHECK-DAG: name: "__SVCount_t",{{.*}}, baseType: ![[CT1_2:[0-9]+]] @@ -18,8 +18,6 @@ void test_locals(void) { // CHECK-DAG: name: "__SVInt8_t",{{.*}}, baseType: ![[CT8:[0-9]+]] // CHECK-DAG: ![[CT8]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTYS8:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS8:[0-9]+]]) // CHECK-DAG: ![[ELTTYS8]] = !DIBasicType(name: "signed char", size: 8, encoding: DW_ATE_signed_char) - // CHECK-DAG: ![[ELTS8]] = !{![[REALELTS8:[0-9]+]]} - // CHECK-DAG: ![[REALELTS8]] = !DISubrange(lowerBound: 0, upperBound: !DIExpression(DW_OP_constu, 8, DW_OP_bregx, 46, 0, DW_OP_mul, DW_OP_constu, 1, DW_OP_minus)) __SVInt8_t s8; // CHECK-DAG: name: "__SVUint8_t",{{.*}}, baseType: ![[CT8:[0-9]+]] @@ -51,12 +49,14 @@ void test_locals(void) { __SVUint32_t u32; // CHECK-DAG: name: "__SVInt64_t",{{.*}}, baseType: ![[CT64:[0-9]+]] - // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS1_64]]) + // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS64:[0-9]+]]) // CHECK-DAG: ![[ELTTY64]] = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed) + // CHECK-DAG: ![[ELTS64]] = !{![[REALELTS64:[0-9]+]]} + // CHECK-DAG: ![[REALELTS64]] = !DISubrange(lowerBound: 0, upperBound: !DIExpression(DW_OP_constu, 1, DW_OP_bregx, 46, 0, DW_OP_mul, DW_OP_constu, 1, DW_OP_minus)) __SVInt64_t s64; // CHECK-DAG: name: "__SVUint64_t",{{.*}}, baseType: ![[CT64:[0-9]+]] - // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS1_64]]) + // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS64]]) // CHECK-DAG: ![[ELTTY64]] = !DIBasicType(name: "unsigned long", size: 64, encoding: DW_ATE_unsigned) __SVUint64_t u64; @@ -71,7 +71,7 @@ void test_locals(void) { __SVFloat32_t f32; // CHECK: name: "__SVFloat64_t",{{.*}}, baseType: ![[CT64:[0-9]+]] - // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS1_64]]) + // CHECK-DAG: ![[CT64]] = !DICompositeType(tag: DW_TAG_array_type, baseType: ![[ELTTY64:[0-9]+]], flags: DIFlagVector, elements: ![[ELTS64]]) // CHECK-DAG: ![[ELTTY64]] = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float) __SVFloat64_t f64; } 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-toolchain-no-rdc.hip b/clang/test/Driver/hip-toolchain-no-rdc.hip index a94299e..2f40fd4 100644 --- a/clang/test/Driver/hip-toolchain-no-rdc.hip +++ b/clang/test/Driver/hip-toolchain-no-rdc.hip @@ -207,7 +207,7 @@ // // AMDGCNSPIRV: "-cc1" "-triple" "spirv64-amd-amdhsa" {{.*}}"-emit-llvm-bc" {{.*}}"-fembed-bitcode=marker" "-disable-llvm-passes" {{.*}} "-o" "[[AMDGCNSPV_BC:.*bc]]" -// AMDGCNSPIRV: {{".*llvm-link.*"}} "-o" "[[AMDGCNSPV_TMP:.*out]]" "[[AMDGCNSPV_BC]]" +// AMDGCNSPIRV: {{".*llvm-link.*"}} "-o" "[[AMDGCNSPV_TMP:.*bc]]" "[[AMDGCNSPV_BC]]" // AMDGCNSPIRV: {{".*llvm-spirv.*"}} "--spirv-max-version=1.6" "--spirv-ext=+all" {{.*}} "[[AMDGCNSPV_TMP]]" {{.*}}"-o" "[[AMDGCNSPV_CO:.*out]]" // AMDGCNSPIRV: "-cc1" "-triple" "amdgcn-amd-amdhsa" {{.*}}"-emit-obj" {{.*}}"-target-cpu" "gfx900"{{.*}} "-o" "[[GFX900_OBJ:.*o]]" // AMDGCNSPIRV: {{".*lld.*"}} {{.*}}"-plugin-opt=mcpu=gfx900" {{.*}} "-o" "[[GFX900_CO:.*out]]" {{.*}}"[[GFX900_OBJ]]" diff --git a/clang/test/Driver/spirv-amd-toolchain.c b/clang/test/Driver/spirv-amd-toolchain.c index 14ba8f4..8f1f0f3 100644 --- a/clang/test/Driver/spirv-amd-toolchain.c +++ b/clang/test/Driver/spirv-amd-toolchain.c @@ -15,5 +15,5 @@ // RUN: %clang -### --target=spirv64-amd-amdhsa %s -nogpulib -nogpuinc 2>&1 \ // RUN: | FileCheck %s --check-prefix=INVOCATION // INVOCATION: "-cc1" "-triple" "spirv64-amd-amdhsa" {{.*}}"-disable-llvm-optzns" {{.*}} "-o" "[[OUTPUT:.+]]" "-x" "c" -// INVOCATION: "{{.*}}llvm-link" "-o" "a.out" "[[OUTPUT]]" -// INVOCATION: "{{.*}}llvm-spirv" "--spirv-max-version=1.6" "--spirv-ext=+all" "--spirv-allow-unknown-intrinsics" "--spirv-lower-const-expr" "--spirv-preserve-auxdata" "--spirv-debug-info-version=nonsemantic-shader-200" "a.out" "-o" "a.out" +// INVOCATION: "{{.*}}llvm-link" "-o" "[[LINKED_OUTPUT:.+]]" "[[OUTPUT]]" +// INVOCATION: "{{.*}}llvm-spirv" "--spirv-max-version=1.6" "--spirv-ext=+all" "--spirv-allow-unknown-intrinsics" "--spirv-lower-const-expr" "--spirv-preserve-auxdata" "--spirv-debug-info-version=nonsemantic-shader-200" "[[LINKED_OUTPUT]]" "-o" "a.out" 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/OpenMP/nvptx_throw_trap.cpp b/clang/test/OpenMP/nvptx_throw_trap.cpp index b13a091..ce11738 100644 --- a/clang/test/OpenMP/nvptx_throw_trap.cpp +++ b/clang/test/OpenMP/nvptx_throw_trap.cpp @@ -1,4 +1,4 @@ -// REQUIRES: nvptx-registered-target +// REQUIRES: nvptx-registered-target, x86-registered-target // RUN: %clang_cc1 -fopenmp -triple nvptx64 -fopenmp-is-target-device %s -S -Wno-openmp-target-exception -o - | FileCheck -check-prefix=DEVICE %s // RUN: %clang_cc1 -fopenmp -triple x86_64-pc-linux-gnu -fopenmp-is-target-device -fcxx-exceptions %s -S -Wno-openmp-target-exception -o - | FileCheck -check-prefix=HOST %s @@ -8,6 +8,6 @@ // HOST-NOT: trap; #pragma omp declare target void foo(void) { - throw 404; + throw 404; } #pragma omp end declare target diff --git a/clang/test/OpenMP/reduction_complex.c b/clang/test/OpenMP/reduction_complex.c index e00caa8..b79903ff 100644 --- a/clang/test/OpenMP/reduction_complex.c +++ b/clang/test/OpenMP/reduction_complex.c @@ -10,6 +10,17 @@ // RUN: -fopenmp-is-target-device -fopenmp-host-ir-file-path %t-ppc-host.bc \ // RUN: -o - | FileCheck %s --check-prefix CHECK +// RUN: %clang_cc1 -verify -fopenmp -fopenmp-cuda-mode -x c++ \ +// RUN: -triple powerpc64le-unknown-unknown \ +// RUN: -fopenmp-targets=spirv64-intel -emit-llvm-bc %s -o \ +// RUN: %t-ppc-host-spv.bc + +// RUN: %clang_cc1 -verify -fopenmp -fopenmp-cuda-mode -x c++ \ +// RUN: -triple spirv64-intel -DCUA \ +// RUN: -fopenmp-targets=spirv64-intel -emit-llvm %s \ +// RUN: -fopenmp-is-target-device -fopenmp-host-ir-file-path %t-ppc-host-spv.bc \ +// RUN: -o - | FileCheck %s --check-prefix CHECK + // expected-no-diagnostics int foo() { int i; @@ -46,9 +57,9 @@ int foo() { // CHECK-NEXT: %[[VAL_244:.*]] = getelementptr inbounds [1 x ptr], ptr %[[VAL_232]], i64 0, i64 0 // CHECK-NEXT: %[[VAL_245:.*]] = getelementptr { float, float }, ptr %[[VAL_243]], i64 1 // CHECK-NEXT: %[[VAL_246:.*]] = load i64, ptr %[[VAL_243]], align 8 -// CHECK-NEXT: %[[VAL_247:.*]] = call i32 @__kmpc_get_warp_size() +// CHECK-NEXT: %[[VAL_247:.*]] = call{{.*}}i32 @__kmpc_get_warp_size() // CHECK-NEXT: %[[VAL_248:.*]] = trunc i32 %[[VAL_247]] to i16 -// CHECK-NEXT: %[[VAL_249:.*]] = call i64 @__kmpc_shuffle_int64(i64 %[[VAL_246]], i16 %[[VAL_240]], i16 %[[VAL_248]]) +// CHECK-NEXT: %[[VAL_249:.*]] = call{{.*}}i64 @__kmpc_shuffle_int64(i64 %[[VAL_246]], i16 %[[VAL_240]], i16 %[[VAL_248]]) // CHECK-NEXT: store i64 %[[VAL_249]], ptr %[[VAL_233]], align 8 // CHECK-NEXT: %[[VAL_250:.*]] = getelementptr i64, ptr %[[VAL_243]], i64 1 // CHECK-NEXT: %[[VAL_251:.*]] = getelementptr i64, ptr %[[VAL_233]], i64 1 @@ -67,7 +78,7 @@ int foo() { // CHECK-NEXT: %[[VAL_263:.*]] = or i1 %[[VAL_262]], %[[VAL_261]] // CHECK-NEXT: br i1 %[[VAL_263]], label %[[VAL_264:.*]], label %[[VAL_265:.*]] // CHECK: then: ; preds = %[[VAL_266:.*]] -// CHECK-NEXT: call void @"{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3foov_l{{[0-9]+}}_omp_outlined_omp_outlined_omp$reduction$reduction_func"(ptr %[[VAL_238]], ptr %[[VAL_232]]) #2 +// CHECK-NEXT: call{{.*}}void @"{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z3foov_l{{[0-9]+}}_omp_outlined_omp_outlined_omp$reduction$reduction_func"(ptr %[[VAL_238]], ptr %[[VAL_232]]) #2 // CHECK-NEXT: br label %[[VAL_267:.*]] // CHECK: else: ; preds = %[[VAL_266]] // CHECK-NEXT: br label %[[VAL_267]] 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/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/incompatible-function-pointer-types-extinfo.c b/clang/test/Sema/incompatible-function-pointer-types-extinfo.c new file mode 100644 index 0000000..b4de356 --- /dev/null +++ b/clang/test/Sema/incompatible-function-pointer-types-extinfo.c @@ -0,0 +1,56 @@ +// RUN: %clang_cc1 -fsyntax-only %s -std=c99 -verify=expected +// RUN: %clang_cc1 -fsyntax-only %s -std=c11 -verify=expected +// RUN: %clang_cc1 -fsyntax-only %s -std=c23 -verify=expected,proto + +// This verifies that -Wincompatible-function-pointer-type diagnostics for +// extended function type information are consistent, also in case of other +// allowed funcion type difference in C. +// +// Test case adapted from issue #41465, with suggestions from PR #160477. + +enum E { A = -1, B }; + +// Case 1: assignment adding noreturn + +int f1 (int); +int (*fp1a)(int) __attribute__((noreturn)) = &f1; // expected-error {{incompatible function pointer types}} +enum E (*fp1b)(int) __attribute__((noreturn)) = &f1; // expected-error {{incompatible function pointer types}} +int (*fp1c)() __attribute__((noreturn)) = &f1; // expected-error {{incompatible function pointer types}} + +// Case 2: assignment adding noescape on arg + +int f2 (int* ) __attribute__((noreturn)); +int (*fp2a)(int* __attribute__((noescape))) __attribute__((noreturn)) = &f2; // expected-error {{incompatible function pointer types}} +int (*fp2b)(int* __attribute__((noescape))) = &f2; // expected-error {{incompatible function pointer types}} + +// Case 3: assignment adding cfi_unchecked_callee + +int f3 (int* ); +int (*fp3a)(int* ) __attribute__((noreturn )) = &f3; // expected-error {{incompatible function pointer types}} +int (*fp3b)(int* __attribute__((noescape))) = &f3; // expected-error {{incompatible function pointer types}} +int (*fp3c)(int* ) __attribute__((noreturn,cfi_unchecked_callee)) = &f3; // expected-error {{incompatible function pointer types}} +int (*fp3d)(int* __attribute__((noescape))) __attribute__(( cfi_unchecked_callee)) = &f3; // expected-error {{incompatible function pointer types}} +int (*fp3e)(int* __attribute__((noescape))) __attribute__((noreturn,cfi_unchecked_callee)) = &f3; // expected-error {{incompatible function pointer types}} + +// Case 4: assignment converting between prototype/no-prototype + +void p1(void); +void i1(int ); +void n1( ); +void p2(void) __attribute__((noreturn)); +void i2(int ) __attribute__((noreturn)); +void n2( ) __attribute__((noreturn)); + +void (*t1)() = p1; +void (*t2)() = i1; // proto-error {{incompatible function pointer types}} +void (*t3)() = n1; +void (*t4)() __attribute__((noreturn)) = p1; // expected-error {{incompatible function pointer types}} +void (*t5)() __attribute__((noreturn)) = i1; // expected-error {{incompatible function pointer types}} +void (*t6)() __attribute__((noreturn)) = n1; // expected-error {{incompatible function pointer types}} + +void (*t7)() = p2; +void (*t8)() = i2; // proto-error {{incompatible function pointer types}} +void (*t9)() = n2; +void (*tA)() __attribute__((noreturn)) = p2; +void (*tB)() __attribute__((noreturn)) = i2; // proto-error {{incompatible function pointer types}} +void (*tC)() __attribute__((noreturn)) = n2; 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/SemaTemplate/concepts.cpp b/clang/test/SemaTemplate/concepts.cpp index 3b7c138..768af09 100644 --- a/clang/test/SemaTemplate/concepts.cpp +++ b/clang/test/SemaTemplate/concepts.cpp @@ -1037,7 +1037,7 @@ void test() { namespace GH66612 { template<typename C> - auto end(C c) ->int; + auto end(C c) ->int; // expected-note {{possible target for call}} template <typename T> concept Iterator = true; @@ -1047,9 +1047,8 @@ namespace GH66612 { { end } -> Iterator; // #66612GH_END }; - static_assert(Container<int>);// expected-error{{static assertion failed}} - // expected-note@-1{{because 'int' does not satisfy 'Container'}} - // expected-note@#66612GH_END{{because 'end' would be invalid: reference to overloaded function could not be resolved; did you mean to call it?}} + static_assert(Container<int>); + // expected-error@#66612GH_END{{reference to overloaded function could not be resolved; did you mean to call it?}} } namespace GH66938 { @@ -1407,7 +1406,6 @@ static_assert(!std::is_constructible_v<span<4>, array<int, 3>>); } - namespace GH162125 { template<typename, int size> concept true_int = (size, true); @@ -1444,3 +1442,37 @@ struct s { void(*test)(int) = &s<bool>::f<int>; } +namespace GH51246 { +void f(); // expected-note {{possible target for call}} +void f(int); // expected-note {{possible target for call}} +void g(); +static_assert(requires { f; }); // expected-error {{reference to overloaded function could not be resolved}} +static_assert(requires { g; }); +struct S { + void mf() { + static_assert(requires { mf(); }); + static_assert(requires { mf; }); // expected-error {{reference to non-static member function must be called}} + static_assert(requires { S::mf; }); // expected-error {{reference to non-static member function must be called}} + } + void mf2(int); // expected-note 2{{possible target for call}} + void mf2() { // expected-note 2{{possible target for call}} + static_assert(requires { mf2; }); // expected-error {{reference to non-static member function must be called}} + static_assert(requires { S::mf2; }); // expected-error {{reference to non-static member function must be called}} + } +}; + +} // namespace GH51246 + + +namespace GH97753 { + +void f(); // expected-note {{possible target for call}} +void f(int); // expected-note {{possible target for call}} + +template<typename T> +concept C = sizeof(T) == 42; + +static_assert( requires {{ &f } -> C;} ); // expected-error {{reference to overloaded function could not be resolved;}} +// expected-error@-1 {{static assertion failed due to requirement 'requires { { &f() } -> C; }'}} + +} diff --git a/clang/unittests/ASTMatchers/CMakeLists.txt b/clang/unittests/ASTMatchers/CMakeLists.txt index 47bd5c1..955566c 100644 --- a/clang/unittests/ASTMatchers/CMakeLists.txt +++ b/clang/unittests/ASTMatchers/CMakeLists.txt @@ -3,7 +3,6 @@ add_clang_unittest(ASTMatchersTests ASTMatchersNodeTest.cpp ASTMatchersNarrowingTest.cpp ASTMatchersTraversalTest.cpp - GtestMatchersTest.cpp CLANG_LIBS clangAST clangASTMatchers diff --git a/clang/unittests/ASTMatchers/GtestMatchersTest.cpp b/clang/unittests/ASTMatchers/GtestMatchersTest.cpp deleted file mode 100644 index 5ee67a9..0000000 --- a/clang/unittests/ASTMatchers/GtestMatchersTest.cpp +++ /dev/null @@ -1,418 +0,0 @@ -//===- unittests/ASTMatchers/GTestMatchersTest.cpp - GTest matcher unit tests // -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "ASTMatchersTest.h" -#include "clang/ASTMatchers/ASTMatchers.h" -#include "clang/ASTMatchers/GtestMatchers.h" - -namespace clang { -namespace ast_matchers { - -constexpr llvm::StringLiteral GtestMockDecls = R"cc( - static int testerr; - -#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - switch (0) \ - case 0: \ - default: // NOLINT - -#define GTEST_NONFATAL_FAILURE_(code) testerr = code - -#define GTEST_FATAL_FAILURE_(code) testerr = code - -#define GTEST_ASSERT_(expression, on_failure) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const int gtest_ar = (expression)) \ - ; \ - else \ - on_failure(gtest_ar) - - // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. - // Don't use this in your code. -#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure) - -#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) -#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) - -#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, v1), on_failure) - -#define EXPECT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) -#define ASSERT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) - -#define EXPECT_EQ(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define EXPECT_NE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) -#define EXPECT_GE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) -#define EXPECT_GT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) -#define EXPECT_LE(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) -#define EXPECT_LT(val1, val2) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) - -#define ASSERT_THAT(value, matcher) \ - ASSERT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) -#define EXPECT_THAT(value, matcher) \ - EXPECT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) - -#define ASSERT_EQ(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) -#define ASSERT_NE(val1, val2) \ - ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) - -#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \ - ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \ - nullptr) \ - .Setter(nullptr, 0, #mock_expr, #call) - -#define ON_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call) - -#define EXPECT_CALL(obj, call) \ - GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call) - - namespace testing { - namespace internal { - class EqHelper { - public: - // This templatized version is for the general case. - template <typename T1, typename T2> - static int Compare(const char* lhs_expression, const char* rhs_expression, - const T1& lhs, const T2& rhs) { - return 0; - } - }; - template <typename T1, typename T2> - int CmpHelperNE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperGE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperGT(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperLE(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - template <typename T1, typename T2> - int CmpHelperLT(const char* expr1, const char* expr2, const T1& val1, - const T2& val2) { - return 0; - } - - // For implementing ASSERT_THAT() and EXPECT_THAT(). The template - // argument M must be a type that can be converted to a matcher. - template <typename M> - class PredicateFormatterFromMatcher { - public: - explicit PredicateFormatterFromMatcher(M m) : matcher_(m) {} - - // This template () operator allows a PredicateFormatterFromMatcher - // object to act as a predicate-formatter suitable for using with - // Google Test's EXPECT_PRED_FORMAT1() macro. - template <typename T> - int operator()(const char* value_text, const T& x) const { - return 0; - } - - private: - const M matcher_; - }; - - template <typename M> - inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher( - M matcher) { - return PredicateFormatterFromMatcher<M>(matcher); - } - - bool GetWithoutMatchers() { return false; } - - template <typename F> - class MockSpec { - public: - MockSpec<F>() {} - - bool InternalDefaultActionSetAt( - const char* file, int line, const char* obj, const char* call) { - return false; - } - - bool InternalExpectedAt( - const char* file, int line, const char* obj, const char* call) { - return false; - } - - MockSpec<F> operator()(bool, void*) { - return *this; - } - }; // class MockSpec - - } // namespace internal - - template <typename T> - int StrEq(T val) { - return 0; - } - template <typename T> - int Eq(T val) { - return 0; - } - - } // namespace testing - - class Mock { - public: - Mock() {} - testing::internal::MockSpec<int> gmock_TwoArgsMethod(int, int) { - return testing::internal::MockSpec<int>(); - } - testing::internal::MockSpec<int> gmock_TwoArgsMethod(bool, void*) { - return testing::internal::MockSpec<int>(); - } - }; // class Mock -)cc"; - -static std::string wrapGtest(llvm::StringRef Input) { - return (GtestMockDecls + Input).str(); -} - -TEST(GtestAssertTest, ShouldMatchAssert) { - std::string Input = R"cc( - void Test() { ASSERT_EQ(1010, 4321); } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestAssert(GtestCmp::Eq, integerLiteral(equals(1010)), - integerLiteral(equals(4321))))); -} - -TEST(GtestAssertTest, ShouldNotMatchExpect) { - std::string Input = R"cc( - void Test() { EXPECT_EQ(2, 3); } - )cc"; - EXPECT_TRUE( - notMatches(wrapGtest(Input), gtestAssert(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestAssertTest, ShouldMatchNestedAssert) { - std::string Input = R"cc( - #define WRAPPER(a, b) ASSERT_EQ(a, b) - void Test() { WRAPPER(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestAssert(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestExpectTest, ShouldMatchExpect) { - std::string Input = R"cc( - void Test() { EXPECT_EQ(1010, 4321); } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestExpect(GtestCmp::Eq, integerLiteral(equals(1010)), - integerLiteral(equals(4321))))); -} - -TEST(GtestExpectTest, ShouldNotMatchAssert) { - std::string Input = R"cc( - void Test() { ASSERT_EQ(2, 3); } - )cc"; - EXPECT_TRUE( - notMatches(wrapGtest(Input), gtestExpect(GtestCmp::Eq, expr(), expr()))); -} - -TEST(GtestExpectTest, NeShouldMatchExpectNe) { - std::string Input = R"cc( - void Test() { EXPECT_NE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Ne, expr(), expr()))); -} - -TEST(GtestExpectTest, LeShouldMatchExpectLe) { - std::string Input = R"cc( - void Test() { EXPECT_LE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Le, expr(), expr()))); -} - -TEST(GtestExpectTest, LtShouldMatchExpectLt) { - std::string Input = R"cc( - void Test() { EXPECT_LT(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Lt, expr(), expr()))); -} - -TEST(GtestExpectTest, GeShouldMatchExpectGe) { - std::string Input = R"cc( - void Test() { EXPECT_GE(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Ge, expr(), expr()))); -} - -TEST(GtestExpectTest, GtShouldMatchExpectGt) { - std::string Input = R"cc( - void Test() { EXPECT_GT(2, 3); } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), gtestExpect(GtestCmp::Gt, expr(), expr()))); -} - -TEST(GtestExpectTest, ThatShouldMatchAssertThat) { - std::string Input = R"cc( - using ::testing::Eq; - void Test() { ASSERT_THAT(2, Eq(2)); } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestAssertThat( - expr(), callExpr(callee(functionDecl(hasName("::testing::Eq"))))))); -} - -TEST(GtestExpectTest, ThatShouldMatchExpectThat) { - std::string Input = R"cc( - using ::testing::Eq; - void Test() { EXPECT_THAT(2, Eq(2)); } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectThat( - expr(), callExpr(callee(functionDecl(hasName("::testing::Eq"))))))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithoutParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestOnCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::None))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithoutParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestOnCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::None))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches(wrapGtest(Input), - gtestOnCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::Some))); -} - -TEST(GtestOnCallTest, CallShouldMatchOnCallWithParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - ON_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestOnCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::Some))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithoutParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), - gtestExpectCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::None))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithoutParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::None))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithParams1) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE( - matches(wrapGtest(Input), - gtestExpectCall(expr(hasType(cxxRecordDecl(hasName("Mock")))), - "TwoArgsMethod", MockArgs::Some))); -} - -TEST(GtestExpectCallTest, CallShouldMatchExpectCallWithParams2) { - std::string Input = R"cc( - void Test() { - Mock mock; - EXPECT_CALL(mock, TwoArgsMethod(1, 2)); - } - )cc"; - EXPECT_TRUE(matches( - wrapGtest(Input), - gtestExpectCall(cxxMemberCallExpr( - callee(functionDecl(hasName("gmock_TwoArgsMethod")))) - .bind("mock_call"), - MockArgs::Some))); -} - -} // end namespace ast_matchers -} // end namespace clang diff --git a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp index 4e97174..95f8ae2 100644 --- a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp +++ b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp @@ -1749,6 +1749,13 @@ TEST(ExprMutationAnalyzerTest, PointeeMutatedByInitToNonConst) { match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_TRUE(isPointeeMutated(Results, AST.get())); } + { + const std::string Code = "void f() { int* x = nullptr; int*& b = x; }"; + auto AST = buildASTFromCodeWithArgs(Code, {}); + auto Results = + match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); + EXPECT_TRUE(isPointeeMutated(Results, AST.get())); + } } TEST(ExprMutationAnalyzerTest, PointeeMutatedByAssignToNonConst) { @@ -1786,6 +1793,14 @@ TEST(ExprMutationAnalyzerTest, PointeeMutatedByPassAsArgument) { match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_TRUE(isPointeeMutated(Results, AST.get())); } + { + const std::string Code = + "void b(int *&); void f() { int* x = nullptr; b(x); }"; + auto AST = buildASTFromCodeWithArgs(Code, {}); + auto Results = + match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); + EXPECT_TRUE(isPointeeMutated(Results, AST.get())); + } } TEST(ExprMutationAnalyzerTest, PointeeMutatedByPassAsArgumentInConstruct) { @@ -1884,6 +1899,14 @@ TEST(ExprMutationAnalyzerTest, PointeeMutatedByExplicitCastToNonConst) { match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); EXPECT_TRUE(isPointeeMutated(Results, AST.get())); } + { + const std::string Code = + "void f() { int* x = nullptr; static_cast<int*&>(x); }"; + auto AST = buildASTFromCodeWithArgs(Code, {"-Wno-everything"}); + auto Results = + match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); + EXPECT_TRUE(isPointeeMutated(Results, AST.get())); + } } TEST(ExprMutationAnalyzerTest, PointeeMutatedByConstCastToNonConst) { diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp index af2dcf6..553c7a3 100644 --- a/clang/utils/TableGen/SveEmitter.cpp +++ b/clang/utils/TableGen/SveEmitter.cpp @@ -243,7 +243,9 @@ public: /// Return the name, mangled with type information. The name is mangled for /// ClassS, so will add type suffixes such as _u32/_s32. - std::string getMangledName() const { return mangleName(ClassS); } + std::string getMangledName(ClassKind CK = ClassS) const { + return mangleName(CK); + } /// As above, but mangles the LLVM name instead. std::string getMangledLLVMName() const { return mangleLLVMName(); } @@ -309,6 +311,7 @@ private: StringMap<uint64_t> FlagTypes; StringMap<uint64_t> MergeTypes; StringMap<uint64_t> ImmCheckTypes; + std::vector<llvm::StringRef> ImmCheckTypeNames; public: SVEEmitter(const RecordKeeper &R) : Records(R) { @@ -320,8 +323,15 @@ public: FlagTypes[RV->getNameInitAsString()] = RV->getValueAsInt("Value"); for (auto *RV : Records.getAllDerivedDefinitions("MergeType")) MergeTypes[RV->getNameInitAsString()] = RV->getValueAsInt("Value"); - for (auto *RV : Records.getAllDerivedDefinitions("ImmCheckType")) - ImmCheckTypes[RV->getNameInitAsString()] = RV->getValueAsInt("Value"); + for (auto *RV : Records.getAllDerivedDefinitions("ImmCheckType")) { + auto [it, inserted] = ImmCheckTypes.try_emplace( + RV->getNameInitAsString(), RV->getValueAsInt("Value")); + if (!inserted) + llvm_unreachable("Duplicate imm check"); + if ((size_t)it->second >= ImmCheckTypeNames.size()) + ImmCheckTypeNames.resize((size_t)it->second + 1); + ImmCheckTypeNames[it->second] = it->first(); + } } /// Returns the enum value for the immcheck type @@ -340,6 +350,13 @@ public: llvm_unreachable("Unsupported flag"); } + /// Returns the name for the immcheck type + StringRef getImmCheckForEnumValue(unsigned Id) { + if ((size_t)Id < ImmCheckTypeNames.size()) + return ImmCheckTypeNames[Id]; + llvm_unreachable("Unsupported imm check"); + } + // Returns the SVETypeFlags for a given value and mask. uint64_t encodeFlag(uint64_t V, StringRef MaskName) const { auto It = FlagTypes.find(MaskName); @@ -389,6 +406,9 @@ public: /// Emit all the __builtin prototypes and code needed by Sema. void createBuiltins(raw_ostream &o); + /// Emit all the __builtin prototypes in JSON format. + void createBuiltinsJSON(raw_ostream &o); + /// Emit all the information needed to map builtin -> LLVM IR intrinsic. void createCodeGenMap(raw_ostream &o); @@ -1552,6 +1572,82 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) { OS << "#endif // GET_SVE_BUILTIN_INFOS\n\n"; } +void SVEEmitter::createBuiltinsJSON(raw_ostream &OS) { + SmallVector<std::unique_ptr<Intrinsic>, 128> Defs; + std::vector<const Record *> RV = Records.getAllDerivedDefinitions("Inst"); + for (auto *R : RV) + createIntrinsic(R, Defs); + + OS << "[\n"; + bool FirstDef = true; + + for (auto &Def : Defs) { + std::vector<std::string> Flags; + + if (Def->isFlagSet(getEnumValueForFlag("IsStreaming"))) + Flags.push_back("streaming-only"); + else if (Def->isFlagSet(getEnumValueForFlag("IsStreamingCompatible"))) + Flags.push_back("streaming-compatible"); + else if (Def->isFlagSet(getEnumValueForFlag("VerifyRuntimeMode"))) + Flags.push_back("feature-dependent"); + + if (Def->isFlagSet(getEnumValueForFlag("IsInZA")) || + Def->isFlagSet(getEnumValueForFlag("IsOutZA")) || + Def->isFlagSet(getEnumValueForFlag("IsInOutZA"))) + Flags.push_back("requires-za"); + + if (Def->isFlagSet(getEnumValueForFlag("IsInZT0")) || + Def->isFlagSet(getEnumValueForFlag("IsOutZT0")) || + Def->isFlagSet(getEnumValueForFlag("IsInOutZT0"))) + Flags.push_back("requires-zt"); + + if (!FirstDef) + OS << ",\n"; + + OS << "{ "; + OS << "\"guard\": \"" << Def->getSVEGuard() << "\","; + OS << "\"streaming_guard\": \"" << Def->getSMEGuard() << "\","; + OS << "\"flags\": \""; + + for (size_t I = 0; I < Flags.size(); ++I) { + if (I != 0) + OS << ','; + OS << Flags[I]; + } + + OS << "\",\"builtin\": \""; + + std::string BuiltinName = Def->getMangledName(Def->getClassKind()); + + OS << Def->getReturnType().str() << " " << BuiltinName << "("; + for (unsigned I = 0; I < Def->getTypes().size() - 1; ++I) { + if (I != 0) + OS << ", "; + + SVEType ParamType = Def->getParamType(I); + + // These are ImmCheck'd but their type names are sufficiently clear. + if (ParamType.isPredicatePattern() || ParamType.isPrefetchOp()) { + OS << ParamType.str(); + continue; + } + + // Pass ImmCheck information by pretending it's a type. + auto Iter = llvm::find_if(Def->getImmChecks(), [I](const auto &Chk) { + return (unsigned)Chk.getImmArgIdx() == I; + }); + if (Iter != Def->getImmChecks().end()) + OS << getImmCheckForEnumValue(Iter->getKind()); + else + OS << ParamType.str(); + } + OS << ");\" }"; + FirstDef = false; + } + + OS << "\n]\n"; +} + void SVEEmitter::createCodeGenMap(raw_ostream &OS) { std::vector<const Record *> RV = Records.getAllDerivedDefinitions("Inst"); SmallVector<std::unique_ptr<Intrinsic>, 128> Defs; @@ -1937,6 +2033,10 @@ void EmitSveBuiltins(const RecordKeeper &Records, raw_ostream &OS) { SVEEmitter(Records).createBuiltins(OS); } +void EmitSveBuiltinsJSON(const RecordKeeper &Records, raw_ostream &OS) { + SVEEmitter(Records).createBuiltinsJSON(OS); +} + void EmitSveBuiltinCG(const RecordKeeper &Records, raw_ostream &OS) { SVEEmitter(Records).createCodeGenMap(OS); } @@ -1965,6 +2065,10 @@ void EmitSmeBuiltins(const RecordKeeper &Records, raw_ostream &OS) { SVEEmitter(Records).createSMEBuiltins(OS); } +void EmitSmeBuiltinsJSON(const RecordKeeper &Records, raw_ostream &OS) { + SVEEmitter(Records).createBuiltinsJSON(OS); +} + void EmitSmeBuiltinCG(const RecordKeeper &Records, raw_ostream &OS) { SVEEmitter(Records).createSMECodeGenMap(OS); } diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp index df14955..866040d 100644 --- a/clang/utils/TableGen/TableGen.cpp +++ b/clang/utils/TableGen/TableGen.cpp @@ -89,12 +89,14 @@ enum ActionType { GenArmMveBuiltinAliases, GenArmSveHeader, GenArmSveBuiltins, + GenArmSveBuiltinsJSON, GenArmSveBuiltinCG, GenArmSveTypeFlags, GenArmSveRangeChecks, GenArmSveStreamingAttrs, GenArmSmeHeader, GenArmSmeBuiltins, + GenArmSmeBuiltinsJSON, GenArmSmeBuiltinCG, GenArmSmeRangeChecks, GenArmSmeStreamingAttrs, @@ -266,6 +268,8 @@ cl::opt<ActionType> Action( "Generate arm_sve.h for clang"), clEnumValN(GenArmSveBuiltins, "gen-arm-sve-builtins", "Generate arm_sve_builtins.inc for clang"), + clEnumValN(GenArmSveBuiltinsJSON, "gen-arm-sve-builtins-json", + "Generate arm_sve_buitins.json"), clEnumValN(GenArmSveBuiltinCG, "gen-arm-sve-builtin-codegen", "Generate arm_sve_builtin_cg_map.inc for clang"), clEnumValN(GenArmSveTypeFlags, "gen-arm-sve-typeflags", @@ -278,6 +282,8 @@ cl::opt<ActionType> Action( "Generate arm_sme.h for clang"), clEnumValN(GenArmSmeBuiltins, "gen-arm-sme-builtins", "Generate arm_sme_builtins.inc for clang"), + clEnumValN(GenArmSmeBuiltinsJSON, "gen-arm-sme-builtins-json", + "Generate arm_sme_buitins.json"), clEnumValN(GenArmSmeBuiltinCG, "gen-arm-sme-builtin-codegen", "Generate arm_sme_builtin_cg_map.inc for clang"), clEnumValN(GenArmSmeRangeChecks, "gen-arm-sme-sema-rangechecks", @@ -551,6 +557,9 @@ bool ClangTableGenMain(raw_ostream &OS, const RecordKeeper &Records) { case GenArmSveBuiltins: EmitSveBuiltins(Records, OS); break; + case GenArmSveBuiltinsJSON: + EmitSveBuiltinsJSON(Records, OS); + break; case GenArmSveBuiltinCG: EmitSveBuiltinCG(Records, OS); break; @@ -569,6 +578,9 @@ bool ClangTableGenMain(raw_ostream &OS, const RecordKeeper &Records) { case GenArmSmeBuiltins: EmitSmeBuiltins(Records, OS); break; + case GenArmSmeBuiltinsJSON: + EmitSmeBuiltinsJSON(Records, OS); + break; case GenArmSmeBuiltinCG: EmitSmeBuiltinCG(Records, OS); break; diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h index e017571..fa49dcd 100644 --- a/clang/utils/TableGen/TableGenBackends.h +++ b/clang/utils/TableGen/TableGenBackends.h @@ -140,6 +140,8 @@ void EmitImmCheckTypes(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSveHeader(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSveBuiltins(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); +void EmitSveBuiltinsJSON(const llvm::RecordKeeper &Records, + llvm::raw_ostream &OS); void EmitSveBuiltinCG(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSveTypeFlags(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSveRangeChecks(const llvm::RecordKeeper &Records, @@ -149,6 +151,8 @@ void EmitSveStreamingAttrs(const llvm::RecordKeeper &Records, void EmitSmeHeader(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSmeBuiltins(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); +void EmitSmeBuiltinsJSON(const llvm::RecordKeeper &Records, + llvm::raw_ostream &OS); void EmitSmeBuiltinCG(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); void EmitSmeRangeChecks(const llvm::RecordKeeper &Records, llvm::raw_ostream &OS); diff --git a/clang/utils/aarch64_builtins_test_generator.py b/clang/utils/aarch64_builtins_test_generator.py new file mode 100755 index 0000000..886d6be --- /dev/null +++ b/clang/utils/aarch64_builtins_test_generator.py @@ -0,0 +1,541 @@ +#!/usr/bin/env python3 +""" +Generate C test files that call ACLE builtins found in a JSON manifest. + +Expected JSON input format (array of objects): +[ + { + "guard": "sve,(sve2p1|sme)", + "streaming_guard": "sme", + "flags": "feature-dependent", + "builtin": "svint16_t svrevd_s16_z(svbool_t, svint16_t);" + }, + ... +] +""" + +from __future__ import annotations + +import argparse +import json +import re +import sys +from collections import defaultdict +from dataclasses import dataclass +from enum import Enum +from itertools import product +from pathlib import Path +from typing import Any, Dict, Iterable, List, Sequence, Tuple + +assert sys.version_info >= (3, 7), "Only Python 3.7+ is supported." + + +# Are we testing arm_sve.h or arm_sme.h based builtins. +class Mode(Enum): + SVE = "sve" + SME = "sme" + + +class FunctionType(Enum): + NORMAL = "normal" + STREAMING = "streaming" + STREAMING_COMPATIBLE = "streaming-compatible" + + +# Builtins are grouped by their required features. +@dataclass(frozen=True, order=True) +class BuiltinContext: + guard: str + streaming_guard: str + flags: Tuple[str, ...] + + def __str__(self) -> str: + return ( + f"// Properties: " + f'guard="{self.guard}" ' + f'streaming_guard="{self.streaming_guard}" ' + f'flags="{",".join(self.flags)}"' + ) + + @classmethod + def from_json(cls, obj: dict[str, Any]) -> "BuiltinContext": + flags = tuple(p.strip() for p in obj["flags"].split(",") if p.strip()) + return cls(obj["guard"], obj["streaming_guard"], flags) + + +# --- Parsing builtins ------------------------------------------------------- + +# Captures the full function *declaration* inside the builtin string, e.g.: +# "svint16_t svrevd_s16_z(svbool_t, svint16_t);" +# group(1) => "svint16_t svrevd_s16_z" +# group(2) => "svbool_t, svint16_t" +FUNC_RE = re.compile(r"^\s*([a-zA-Z_][\w\s\*]*[\w\*])\s*\(\s*([^)]*)\s*\)\s*;\s*$") + +# Pulls the final word out of the left side (the function name). +NAME_RE = re.compile(r"([a-zA-Z_][\w]*)\s*$") + + +def parse_builtin_declaration(decl: str) -> Tuple[str, List[str]]: + """Return (func_name, param_types) from a builtin declaration string. + + Example: + decl = "svint16_t svrevd_s16_z(svbool_t, svint16_t);" + => ("svrevd_s16_z", ["svbool_t", "svint16_t"]) + """ + m = FUNC_RE.match(decl) + if not m: + raise ValueError(f"Unrecognized builtin declaration syntax: {decl!r}") + + left = m.group(1) # return type + name + params = m.group(2).strip() + + name_m = NAME_RE.search(left) + if not name_m: + raise ValueError(f"Could not find function name in: {decl!r}") + func_name = name_m.group(1) + + param_types: List[str] = [] + if params: + # Split by commas respecting no pointers/arrays with commas (not expected here) + param_types = [p.strip() for p in params.split(",") if p.strip()] + + return func_name, param_types + + +# --- Variable synthesis ----------------------------------------------------- + +# Pick a safe (ideally non-zero) value for literal types +LITERAL_TYPES_MAP: dict[str, str] = { + "ImmCheck0_0": "0", + "ImmCheck0_1": "1", + "ImmCheck0_2": "2", + "ImmCheck0_3": "2", + "ImmCheck0_7": "2", + "ImmCheck0_13": "2", + "ImmCheck0_15": "2", + "ImmCheck0_31": "2", + "ImmCheck0_63": "2", + "ImmCheck0_255": "2", + "ImmCheck1_1": "1", + "ImmCheck1_3": "2", + "ImmCheck1_7": "2", + "ImmCheck1_16": "2", + "ImmCheck1_32": "2", + "ImmCheck1_64": "2", + "ImmCheck2_4_Mul2": "2", + "ImmCheckComplexRot90_270": "90", + "ImmCheckComplexRotAll90": "90", + "ImmCheckCvt": "2", + "ImmCheckExtract": "2", + "ImmCheckLaneIndexCompRotate": "1", + "ImmCheckLaneIndexDot": "1", + "ImmCheckLaneIndex": "1", + "ImmCheckShiftLeft": "2", + "ImmCheckShiftRightNarrow": "2", + "ImmCheckShiftRight": "2", + "enum svpattern": "SV_MUL3", + "enum svprfop": "SV_PSTL1KEEP", + "void": "", +} + + +def make_arg_for_type(ty: str) -> Tuple[str, str]: + """Return (var_decl, var_use) for a parameter type. + + Literal types return an empty declaration and a value that will be accepted + by clang's semantic literal validation. + """ + # Compress whitespace and remove non-relevant qualifiers. + ty = re.sub(r"\s+", " ", ty.strip()).replace(" const", "") + if ty in LITERAL_TYPES_MAP: + return "", LITERAL_TYPES_MAP[ty] + + if ty.startswith("ImmCheck") or ty.startswith("enum "): + print(f"Failed to parse potential literal type: {ty}", file=sys.stderr) + + name = ty.replace(" ", "_").replace("*", "ptr") + "_val" + return f"{ty} {name};", name + + +# NOTE: Parsing is limited to the minimum required for guard strings. +# Specifically the expected input is of the form: +# feat1,feat2,...(feat3 | feat4 | ...),... +def expand_feature_guard( + guard: str, flags: Sequence[str], base_feature: str = "" +) -> list[set[str]]: + """ + Expand a guard expression where ',' = AND and '|' = OR, with parentheses + grouping OR-expressions. Returns a list of feature sets. + """ + if not guard: + return [] + + parts = re.split(r",(?![^(]*\))", guard) + + choices_per_part = [] + for part in parts: + if part.startswith("(") and part.endswith(")"): + choices_per_part.append(part[1:-1].split("|")) + else: + choices_per_part.append([part]) + + # Add feature that is common to all + if base_feature: + choices_per_part.append([base_feature]) + + if "requires-zt" in flags: + choices_per_part.append(["sme2"]) + + # construct list of feature sets + results = [] + for choice in product(*choices_per_part): + choice_set = set(choice) + results.append(choice_set) + + # remove superset and duplicates + unique = [] + for s in results: + if any(s > other for other in results): + continue + if s not in unique: + unique.append(s) + + return unique + + +def cc1_args_for_features(features: set[str]) -> str: + return " ".join("-target-feature +" + s for s in sorted(features)) + + +def sanitise_guard(s: str) -> str: + """Rewrite guard strings in a form more suitable for file naming.""" + replacements = { + ",": "_AND_", + "|": "_OR_", + "(": "_LP_", + ")": "_RP_", + } + for k, v in replacements.items(): + s = s.replace(k, v) + + # Collapse multiple underscores + s = re.sub(r"_+", "_", s) + return s.strip("_") + + +def make_filename(prefix: str, ctx: BuiltinContext, ext: str) -> str: + parts = [sanitise_guard(ctx.guard), sanitise_guard(ctx.streaming_guard)] + sanitised_guard = "___".join(p for p in parts if p) + + if "streaming-only" in ctx.flags: + prefix += "_streaming_only" + elif "streaming-compatible" in ctx.flags: + prefix += "_streaming_compatible" + elif "feature-dependent" in ctx.flags: + prefix += "_feature_dependent" + else: + prefix += "_non_streaming_only" + + return f"{prefix}_{sanitised_guard}{ext}" + + +# --- Code Generation -------------------------------------------------------- + + +def emit_streaming_guard_run_lines(ctx: BuiltinContext) -> str: + """Emit lit RUN lines that will exercise the relevant Sema diagnistics.""" + run_prefix = "// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu" + out: List[str] = [] + + # All RUN lines have SVE and SME enabled + guard_features = expand_feature_guard(ctx.guard, ctx.flags, "sme") + streaming_guard_features = expand_feature_guard( + ctx.streaming_guard, ctx.flags, "sve" + ) + + if "streaming-only" in ctx.flags: + assert not guard_features + # Generate RUN lines for features only available to streaming functions + for feats in streaming_guard_features: + out.append( + f"{run_prefix} {cc1_args_for_features(feats)} -verify=streaming-guard" + ) + elif "streaming-compatible" in ctx.flags: + assert not guard_features + # NOTE: Streaming compatible builtins don't require SVE. + # Generate RUN lines for features available to all functions. + for feats in expand_feature_guard(ctx.streaming_guard, ctx.flags): + out.append(f"{run_prefix} {cc1_args_for_features(feats)} -verify") + out.append("// expected-no-diagnostics") + elif "feature-dependent" in ctx.flags: + assert guard_features and streaming_guard_features + combined_features = expand_feature_guard( + ctx.guard + "," + ctx.streaming_guard, ctx.flags + ) + + # Generate RUN lines for features only available to normal functions + for feats in guard_features: + if feats not in combined_features: + out.append(f"{run_prefix} {cc1_args_for_features(feats)} -verify=guard") + + # Geneate RUN lines for features only available to streaming functions + for feats in streaming_guard_features: + if feats not in combined_features: + out.append( + f"{run_prefix} {cc1_args_for_features(feats)} -verify=streaming-guard" + ) + + # Generate RUN lines for features available to all functions + for feats in combined_features: + out.append(f"{run_prefix} {cc1_args_for_features(feats)} -verify") + + out.append("// expected-no-diagnostics") + else: + assert not streaming_guard_features + # Geneate RUN lines for features only available to normal functions + for feats in guard_features: + out.append(f"{run_prefix} {cc1_args_for_features(feats)} -verify=guard") + + return "\n".join(out) + + +def emit_streaming_guard_function( + ctx: BuiltinContext, + var_decls: Sequence[str], + calls: Sequence[str], + func_name: str, + func_type: FunctionType = FunctionType.NORMAL, +) -> str: + """Emit a C function calling all builtins. + + `calls` is a sequence of tuples: (name, call_line) + """ + # Expected Sema diagnostics for invalid usage + require_diagnostic = require_streaming_diagnostic = False + if "streaming-only" in ctx.flags: + if func_type != FunctionType.STREAMING: + require_streaming_diagnostic = True + elif "streaming-compatible" in ctx.flags: + pass # streaming compatible builtins are always available + elif "feature-dependent" in ctx.flags: + guard_features = expand_feature_guard(ctx.guard, ctx.flags, "sme") + streaming_guard_features = expand_feature_guard( + ctx.streaming_guard, ctx.flags, "sve" + ) + combined_features = expand_feature_guard( + ctx.guard + "," + ctx.streaming_guard, ctx.flags + ) + + if func_type != FunctionType.NORMAL: + if any(feats not in combined_features for feats in guard_features): + require_diagnostic = True + if func_type != FunctionType.STREAMING: + if any( + feats not in combined_features for feats in streaming_guard_features + ): + require_streaming_diagnostic = True + else: + if func_type != FunctionType.NORMAL: + require_diagnostic = True + + out: List[str] = [] + + # Emit test function declaration + attr: list[str] = [] + if func_type == FunctionType.STREAMING: + attr.append("__arm_streaming") + elif func_type == FunctionType.STREAMING_COMPATIBLE: + attr.append("__arm_streaming_compatible") + + if "requires-za" in ctx.flags: + attr.append('__arm_inout("za")') + if "requires-zt" in ctx.flags: + attr.append('__arm_inout("zt0")') + out.append(f"void {func_name}(void) " + " ".join(attr) + "{") + + # Emit variable declarations + for v in var_decls: + out.append(f" {v}") + if var_decls: + out.append("") + + # Emit calls + for call in calls: + if require_diagnostic and require_streaming_diagnostic: + out.append( + " // guard-error@+2 {{builtin can only be called from a non-streaming function}}" + ) + out.append( + " // streaming-guard-error@+1 {{builtin can only be called from a streaming function}}" + ) + elif require_diagnostic: + out.append( + " // guard-error@+1 {{builtin can only be called from a non-streaming function}}" + ) + elif require_streaming_diagnostic: + out.append( + " // streaming-guard-error@+1 {{builtin can only be called from a streaming function}}" + ) + out.append(f" {call}") + + out.append("}") + return "\n".join(out) + "\n" + + +def natural_key(s: str): + """Allow sorting akin to "sort -V""" + return [int(text) if text.isdigit() else text for text in re.split(r"(\d+)", s)] + + +def build_calls_for_group(builtins: Iterable[str]) -> Tuple[List[str], List[str]]: + """From a list of builtin declaration strings, produce: + - a sorted list of unique variable declarations + - a sorted list of builtin calls + """ + var_decls: List[str] = [] + seen_types: set[str] = set() + calls: List[str] = [] + + for decl in builtins: + fn, param_types = parse_builtin_declaration(decl) + + arg_names: List[str] = [] + for i, ptype in enumerate(param_types): + vdecl, vname = make_arg_for_type(ptype) + if vdecl and vdecl not in seen_types: + seen_types.add(vdecl) + var_decls.append(vdecl) + arg_names.append(vname) + + calls.append(f"{fn}(" + ", ".join(arg_names) + ");") + + # Natural sort (e.g. int8_t before int16_t) + calls.sort(key=natural_key) + var_decls.sort(key=natural_key) + + return var_decls, calls + + +def gen_streaming_guard_tests(mode: Mode, json_path: Path, out_dir: Path) -> None: + """Generate a set of Clang Sema test files to ensure SVE/SME builtins are + callable based on the function type, or the required diagnostic is emitted. + """ + try: + data = json.loads(json_path.read_text()) + except json.JSONDecodeError as e: + print(f"Failed to parse JSON {json_path}: {e}", file=sys.stderr) + return + + # Group by (guard, streaming_guard) + by_guard: Dict[BuiltinContext, List[str]] = defaultdict(list) + for obj in data: + by_guard[BuiltinContext.from_json(obj)].append(obj["builtin"]) + + # For each guard pair, emit 3 functions + for builtin_ctx, builtin_decls in by_guard.items(): + var_decls, calls = build_calls_for_group(builtin_decls) + + out_parts: List[str] = [] + out_parts.append( + "// NOTE: File has been autogenerated by utils/aarch64_builtins_test_generator.py" + ) + out_parts.append(emit_streaming_guard_run_lines(builtin_ctx)) + out_parts.append("") + out_parts.append("// REQUIRES: aarch64-registered-target") + out_parts.append("") + out_parts.append(f"#include <arm_{mode.value}.h>") + out_parts.append("") + out_parts.append(str(builtin_ctx)) + out_parts.append("") + out_parts.append( + emit_streaming_guard_function(builtin_ctx, var_decls, calls, "test") + ) + out_parts.append( + emit_streaming_guard_function( + builtin_ctx, var_decls, calls, "test_streaming", FunctionType.STREAMING + ) + ) + out_parts.append( + emit_streaming_guard_function( + builtin_ctx, + var_decls, + calls, + "test_streaming_compatible", + FunctionType.STREAMING_COMPATIBLE, + ) + ) + + output = "\n".join(out_parts).rstrip() + "\n" + + if out_dir: + out_dir.mkdir(parents=True, exist_ok=True) + filename = make_filename(f"arm_{mode.value}", builtin_ctx, ".c") + (out_dir / filename).write_text(output) + else: + print(output) + + return + + +# --- Main ------------------------------------------------------------------- + + +def existing_file(path: str) -> Path: + p = Path(path) + if not p.is_file(): + raise argparse.ArgumentTypeError(f"{p} is not a valid file") + return p + + +def main(argv: Sequence[str] | None = None) -> int: + ap = argparse.ArgumentParser(description="Emit C tests for SVE/SME builtins") + ap.add_argument( + "json", type=existing_file, help="Path to json formatted builtin descriptions" + ) + ap.add_argument( + "--out-dir", type=Path, default=None, help="Output directory (default: stdout)" + ) + ap.add_argument( + "--gen-streaming-guard-tests", + action="store_true", + help="Generate C tests to validate SVE/SME builtin usage base on streaming attribute", + ) + ap.add_argument( + "--gen-target-guard-tests", + action="store_true", + help="Generate C tests to validate SVE/SME builtin usage based on target features", + ) + ap.add_argument( + "--gen-builtin-tests", + action="store_true", + help="Generate C tests to exercise SVE/SME builtins", + ) + ap.add_argument( + "--base-target-feature", + choices=["sve", "sme"], + help="Force builtin source (sve: arm_sve.h, sme: arm_sme.h)", + ) + + args = ap.parse_args(argv) + + # When not forced, try to infer the mode from the input, defaulting to SVE. + if args.base_target_feature: + mode = Mode(args.base_target_feature) + elif args.json and args.json.name == "arm_sme_builtins.json": + mode = Mode.SME + else: + mode = Mode.SVE + + # Generate test file + if args.gen_streaming_guard_tests: + gen_streaming_guard_tests(mode, args.json, args.out_dir) + if args.gen_target_guard_tests: + ap.error("--gen-target-guard-tests not implemented yet!") + if args.gen_builtin_tests: + ap.error("--gen-builtin-tests not implemented yet!") + + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/clang/utils/analyzer/Dockerfile b/clang/utils/analyzer/Dockerfile index cc73ed9..f908cbe 100644 --- a/clang/utils/analyzer/Dockerfile +++ b/clang/utils/analyzer/Dockerfile @@ -1,4 +1,4 @@ -FROM ubuntu:bionic +FROM docker.io/ubuntu:bionic RUN apt-get update && apt-get install -y \ apt-transport-https \ diff --git a/clang/www/c_status.html b/clang/www/c_status.html index d41b5cc..380f664 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -320,6 +320,57 @@ conformance.</p> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3460.pdf">N3460</a></td> <td class="full" align="center">Clang 12</td> </tr> + <!-- Brno Aug 2025 Papers --> + <tr> + <td>Matching of Multi-Dimensional Arrays in Generic Selection Expressions</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3348.pdf">N3348</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>The __COUNTER__ predefined macro</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3457.htm">N3457</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Chasing Ghosts I: constant expressions v2</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3558.htm">N3558</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Earthly Demon XV: Definition of Main</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3623.pdf">N3623</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>static_assert without UB</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3525.htm">N3525</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Allow calling static inline within extern inline</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3622.txt">N3622</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Generic replacement (v. 2 of quasi-literals)</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3605.pdf">N3605</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Member access of an incomplete object</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3532.pdf">N3532</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Representation of Pointers and nullptr_t</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3563.pdf">N3563</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> + <tr> + <td>Classification of the register storage-class specifier</td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3544.txt">N3544</a></td> + <td class="unknown" align="center">Unknown</td> + </tr> </table> </details> |